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

Source: Dev.to

Introduction

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.

The real advantage is that 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: data remains private, automation logic stays under your control, and you can integrate with local devices without pushing everything to third‑party services.

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

What You’ll Build

• A self‑hosted Node‑RED instance running locally.
• A 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

Running Node‑RED locally gives you several practical benefits:

• Privacy: Your automation logic never leaves your network.
• Local device access: Directly control hardware on the same LAN.
• Cost savings: No recurring hosting fees.
• Rapid prototyping: No deployment steps, instant feedback.
• Live debugging: Inspect flows in real time on your own machine.

Typical use‑cases include:

• Receiving webhooks (GitHub, Slack, Stripe, Twilio, etc.).
• Controlling IoT devices while you’re away.
• Sharing dashboards with a remote team.
• Testing integrations safely before production.

Node‑RED Overview

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

Key features

• 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 a Raspberry Pi

Prerequisites

Make sure you have a recent Node.js version (v18 or higher).

node --version   # should show v18.x or higher

Install Node.js (Ubuntu/Debian example)

curl -fsSL https://deb.nodesource.com/setup_20.x | sudo -E bash -
sudo apt-get install -y nodejs
npm --version   # verify npm is installed

Install Node‑RED

Global installation (recommended)

npm install -g --unsafe-perm node-red

Local installation (optional)

mkdir node-red
cd node-red
npm init -y
npm install --unsafe-perm node-red

Verify installation

# Global
node-red --version

# Local
npx node-red --version

You should see something like v4.x.x.

Run Node‑RED

# Global
node-red

# Local
npx node-red

You’ll see logs similar to:

Node-RED version: 4.x.x
Node.js version: v20.x.x
URL: http://127.0.0.1:1880/

Open your browser and navigate to http://localhost:1880 to access the flow editor.

Create a Simple Test Flow

1. Drag an Inject node onto the canvas.
2. Drag a Debug node next to it.
3. Wire Inject → Debug.
4. Click Deploy.

Press the inject button; the payload will appear in the Debug panel. This confirms that Node‑RED is working locally.

Expose Node‑RED to the Internet with Pinggy

Many projects eventually need:

• Remote access from a phone or tablet
• Remote monitoring dashboards
• Webhook receiver endpoints
• Shared dashboards for teammates

Pinggy creates a secure SSH tunnel without requiring router configuration.

ssh -p 443 -R0:localhost:1880 qr@free.pinggy.io

Pinggy will output a public HTTPS URL, e.g.:

https://randomstring.a.pinggy.link

Open that URL in any browser. The qr@ option also prints a QR code for quick mobile access.

Note: On the free plan the URL changes after each reconnection. For a stable address (useful for webhooks), consider Pinggy Pro’s persistent subdomains.

Using Node‑RED with Webhooks

Once reachable from the internet, you can add HTTP In nodes to accept webhook calls from services such as:

• GitHub Actions
• Slack
• Stripe payments
• Twilio SMS
• Any REST API provider

Typical flow pattern:

1. HTTP In (listen on /webhook) → Function (process payload) → Switch/Change (logic) → Output (e.g., toggle a relay, store data, send an alert).

Building a Remote Dashboard

Node‑RED Dashboard nodes let you create UI panels (charts, switches, text). Access them via the Pinggy URL, making it easy to:

• Monitor sensor readings (temperature, humidity, motion)
• Control relays or switches remotely
• View logs or alerts in real time

Development Workflow

1. Build locally – design and test flows on your machine.
2. Connect to real webhook providers – use the public Pinggy URL.
3. Iterate quickly – deploy changes instantly, no cloud redeployments needed.

This approach gives you the convenience of cloud‑style development while keeping everything under your control.

Conclusion

Self‑hosting Node‑RED provides a lightweight, flexible automation platform that runs on your own hardware. By tunneling it with Pinggy you eliminate the usual networking hurdles—no router configuration, no port forwarding, no public hosting setup.

• Install Node‑RED → run locally → expose with Pinggy → automate, integrate, and experiment from anywhere.

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