DEV Community

Lightning Developer
Lightning Developer

Posted on

Self-Hosting Node-RED: Build Local Automations and Access Them Anywhere

#pinggy #webdev #devops #automation

If you’ve ever wanted to connect sensors, APIs, dashboards, and online services without writing a full backend from scratch, Node-RED is one of the easiest tools you can adopt. It lets you create automation logic visually, by wiring blocks (called nodes) together like a flowchart.

But here’s the real advantage: you don’t need a cloud platform to use it.

When you self-host Node-RED on your own laptop, desktop, or Raspberry Pi, your workflows stay inside your environment. Your data remains private, your automation logic stays under your control, and you can integrate with local devices without pushing everything to third-party services.

And if you also want to open Node-RED to the outside world for remote access or webhooks, you can use Pinggy to create a secure tunnel in seconds.

In this guide, we’ll set up a local Node-RED instance and connect it to the internet using Pinggy, so you can access your flows from anywhere.

What You’re Building

By the end, you’ll have:

  • A self-hosted Node-RED instance running locally
  • A working browser-based Node-RED editor at http://localhost:1880
  • A public URL via Pinggy to access Node-RED remotely
  • The ability to receive webhooks from external services

Why Self-Host Node-RED?

Node-RED is commonly used in IoT, automation, and integration tasks. While hosted solutions exist, running it locally gives you advantages that matter in real projects:

  • Your automation logic stays private
  • You can connect directly to devices in your local network
  • You avoid recurring hosting costs
  • You can prototype quickly without deployment steps
  • You can debug flows with live local access

Self-hosting becomes especially useful if you need to:

  • Receive webhooks (GitHub, Slack, Stripe, Twilio, etc.)
  • Control IoT devices while you’re outside your home or office
  • Share dashboards with a team remotely
  • Test integrations safely before production

What is Node-RED?

Node-RED is an open-source flow-based programming tool (originally created by IBM) designed to connect:

  • hardware devices
  • databases
  • HTTP APIs
  • automation tools
  • cloud services

Instead of building everything manually, you drag nodes into a workspace, wire them, and deploy.

Key features you’ll notice immediately

  • Visual flow editor (drag, drop, wire)
  • Huge community node library
  • Dashboard support for UI monitoring/control
  • Function nodes for custom JavaScript logic
  • Import/export flows as JSON
  • Runs well even on Raspberry Pi

Prerequisites

Before installation, confirm you have a modern Node.js version.

Check Node.js version 

node --version
Enter fullscreen mode Exit fullscreen mode

Node-RED works best with Node.js v18 or higher.

Install / update Node.js on Linux (Ubuntu/Debian) 

curl -fsSL https://deb.nodesource.com/setup_20.x | sudo -E bash -
sudo apt-get install -y nodejs
Enter fullscreen mode Exit fullscreen mode

Verify npm 

npm --version
Enter fullscreen mode Exit fullscreen mode

Step 1: Install Node-RED

You can install Node-RED globally (recommended), so it can run from anywhere.

Global install 

npm install -g --unsafe-perm node-red
Enter fullscreen mode Exit fullscreen mode

Optional: Local project install

If you prefer not to install globally:

mkdir node-red
cd node-red
npm init -y
npm install --unsafe-perm node-red
Enter fullscreen mode Exit fullscreen mode

Confirm installation 

# If installed globally
node-red --version

# If installed locally
npx node-red --version
Enter fullscreen mode Exit fullscreen mode

You should see something like v4.x.x.

Step 2: Run Node-RED Locally

Now start the Node-RED server.

# If installed globally
node-red

# If installed locally
npx node-red
Enter fullscreen mode Exit fullscreen mode

You’ll see logs confirming Node-RED is running, usually like:

  • Node-RED version
  • Node.js version
  • URL: http://127.0.0.1:1880/

Now open your browser and visit:

http://localhost:1880

You will see the Node-RED flow editor.

Step 3: Try a Simple Flow (Quick Confidence Test)

Before exposing it to the internet, it’s smart to ensure it’s working.

Create a simple flow:

  1. Drag inject node to the canvas
  2. Drag debug node next to it
  3. Wire inject → debug
  4. Click Deploy
  5. Press the inject button

Output will appear in the Debug panel.
This confirms your runtime and editor are working correctly.

Step 4: Access Node-RED from Anywhere with Pinggy

Local access is great, but most real projects eventually need one of these:

  • remote access from phone
  • remote monitoring
  • webhook receiver endpoint
  • sharing a dashboard with teammates

This is where Pinggy becomes useful. It creates a secure tunnel using SSH, without needing you to install extra tools or configure routers.

Create a tunnel (Node-RED must be running)

Open a new terminal and run:

ssh -p 443 -R0:localhost:1880 qr@free.pinggy.io
Enter fullscreen mode Exit fullscreen mode

Pinggy will output a public HTTPS URL like:

  • https://randomstring.a.pinggy.link

Open that URL in your browser.
You’ll see your Node-RED editor, now accessible from anywhere.

A nice touch: the qr@ option also prints a QR code in the terminal so you can instantly open it on mobile.

Persistent URLs (Optional)

In the free plan, the URL changes after reconnecting.

If you want a stable URL for a long-running project (especially webhooks), Pinggy Pro supports persistent subdomains, so your Node-RED address stays the same.

What You Can Do With Public Node-RED Access

Once Node-RED is reachable from the internet, it becomes more than a local automation tool.

1) Receive Webhooks

Use HTTP In nodes to accept webhook calls from:

  • GitHub actions
  • Slack
  • Stripe payments
  • Twilio SMS
  • any REST API provider

This turns your self-hosted Node-RED into a real automation server.

2) Remote IoT Monitoring and Control

You can expose flows that:

  • read sensor values (temperature, humidity, motion)
  • toggle relays or switches
  • send alerts based on conditions
  • log readings to a database

Even if the devices are on your local Wi-Fi, you can still interact remotely.

3) Share Dashboards

Using Node-RED Dashboard nodes, you can build UI panels and access them via the Pinggy link. This is perfect for demos, internal tools, or remote monitoring.

4) Test Integrations Faster

Instead of deploying to cloud environments repeatedly, you can:

  • build locally
  • connect to real webhook providers
  • test instantly
  • iterate quickly

It feels like cloud development, but stays under your control.

Conclusion

Self-hosting Node-RED gives you a powerful automation platform that runs on your own hardware and follows your rules. It’s lightweight, flexible, and extremely practical for IoT, workflow integrations, and rapid prototyping.

And by adding Pinggy, you remove the usual pain of networking setup. No router configuration, no port forwarding complexity, no complicated public hosting.

Just install Node-RED, run it locally, tunnel it with Pinggy, and you’re ready to automate, integrate, and experiment from anywhere.

Your flows stay yours. Your system stays private. And your automation becomes truly usable in the real world.

Reference

Self-Hosting Node-RED

Top comments (0)