Getting Started

Your managed Node-RED at server.camp is ready. Node-RED is a visual automation tool for connecting systems and services without deep programming knowledge — the Swiss Army knife for integrations and data flows. This guide is for freelancers, SMBs, and nonprofits that want to automate recurring digital processes and connect their systems together.

Many organizations handle the same tasks over and over manually: transferring data from one system to another, sending notifications, assembling reports, processing forms. It costs time — and introduces errors.

Node-RED lets you configure these workflows visually, once, and have them run automatically. Build by drag-and-drop in the browser — no programming knowledge required (though JavaScript is available for advanced users and makes many things easier).

Common use cases:

• Notifications: Send an email or Mattermost message when a new order arrives
• Data transfer: Automatically write form submissions from a website into a CRM or spreadsheet
• Monitoring response: When Uptime Kuma reports an outage, automatically create a ticket in Zammad
• Document processing: Automatically pass files to Paperless-ngx
• Regular reports: Send a daily summary from multiple sources by email at 8 AM
• Webhook processing: Trigger an action when a GitHub/GitLab event occurs
• Custom APIs: Provide HTTP endpoints for forms, mini-apps, or other systems
• Custom dashboards: Web interfaces with real-time data, forms, and input fields
• IoT and hardware: Process sensor data from machines, measurement devices, or smart home systems

Node-RED works with flows — visual diagrams where nodes are connected by lines. Data flows from left to right through the connections.

Every node has a job:

How a flow works

[Receive HTTP POST] → [Parse JSON] → [Format message] → [Send Mattermost notification]

This flow receives a webhook request, reads the data inside it, and sends a formatted notification to Mattermost. The entire setup takes about 10 minutes.

Node-RED has a browser-based interface with three areas:

• Left: Node palette — all available node types; drag them into the flow
• Center: Flow editor — build flows visually here; multiple tabs for different flows
• Right: Info & Debug — documentation for the selected node and debug output

Top right: the “Deploy” button — activates your changes. Until you deploy, the existing flows keep running unchanged.

1. Explore the interface — click through the standard nodes, read the Info panel
2. Build your first simple flow — e.g. a scheduled email (see below)
3. Understand the debug node — the most important tool during development
4. Install community nodes — extend the palette for your integrations
5. Build production flows — webhooks, integrations, automations
6. Add error handling — catch nodes for robust flows
7. Back up flows — export as JSON, version them

A simple starting example: every morning at 9 AM, Node-RED sends an email.

Step 1: Inject node (schedule)

1. Drag an inject node from the palette into the flow
2. Double-click to open settings
3. Set “Repeat” to “at a specific time”
4. Set time: 9:00 AM, daily

Step 2: Email node

1. Add an e-mail node from the palette (if needed, install it via Menu → Manage palette → Install: node-red-node-email)
2. Enter SMTP server details (server address, port, username, password)
3. Configure recipient, subject, and message text

Step 3: Connect and deploy

1. Connect the output of the inject node to the input of the email node (draw a line)
2. Click “Deploy” in the top right
3. Done — the email will arrive every morning at 9 AM

Trigger manually for testing

Every inject node has a small button on the left. Click it to trigger the flow immediately — no need to wait until 9 AM while developing.

Webhooks connect systems together: when System A does something (e.g. new order), it notifies System B (Node-RED), which then triggers further actions.

1. Drag an http in node into the flow
2. Method: POST, URL: e.g. /webhook/new-order
3. Node-RED provides an endpoint at https://your-nodered.srv.camp/webhook/new-order
4. Attach an http response node so the sender receives a confirmation

1. Attach a debug node — shows which data arrives in the Debug panel
2. Use a function node or change node to read and reformat data
3. Forward the output to the desired service

Always debug first

Always attach a debug node to the output of your http in node first. The Debug panel shows exactly what data arrives — and tells you which fields you can work with. Only once the data structure is clear should you build the rest of the flow.

Scenario: Uptime Kuma reports a website outage → Node-RED automatically creates a ticket in Zammad and posts a message in Mattermost.

[Receive webhook from Uptime Kuma]
    → [Check status: is it "DOWN"?]
        → [Create Zammad ticket via REST API]
        → [Mattermost message: "⚠️ Website X is down since HH:MM"]
    → [http response: 200 OK]

Required nodes: http in, switch, http request (Zammad API), mattermost node or http request (webhook), http response

Scenario: A contact form on your website sends data to Node-RED → automatic confirmation email to the sender + entry in the CRM.

[Receive HTTP POST /contact-form]
    → [Validate input data]
    → [Send confirmation email to sender]
    → [Send data to CRM API]
    → [Notify sales team in Mattermost]
    → [http response: "Thank you for your message"]

Required nodes: http in, function (validation), e-mail, http request (CRM API), mattermost, http response

Scenario: Every morning at 8 AM, data from multiple sources is combined and sent as an email report.

[Schedule: daily at 8:00]
    → [Fetch sales data from shop API]
    → [Fetch ticket stats from Zammad API]
    → [Fetch uptime data]
    → [Merge data and format as HTML table]
    → [Send email to leadership]

Required nodes: inject (schedule), multiple http request, join, template (HTML), e-mail

Scenario: 48 hours before an association event, an automatic reminder is sent to the #events Mattermost channel and by email to registered participants.

[Schedule: check hourly]
    → [Query calendar API / JSON file with events]
    → [Check: is there an event in 48h?]
        → Yes: [Send reminder to Mattermost]
               [Send email to participant list]
        → No: [Do nothing]

Scenario: For every new order in the online shop, the sales team is notified and an invoice draft is prepared.

[Receive webhook from shop]
    → [Extract order data: items, amount, customer]
    → [Mattermost: "🛒 New order #1234 from Company X for €1,299"]
    → [Send invoice data to accounting API]
    → [http response: 200 OK]

Start small, build incrementally

Start every flow with the simplest possible setup: Input → Debug. When data arrives correctly, add the next node. You’ll catch errors immediately and build robust flows step by step.

Via Menu → Manage palette → Install, choose from thousands of community nodes. The most useful ones for server.camp users:

Browse all available nodes at flows.nodered.org.

Choose community nodes carefully

Check download counts and last-updated dates for community nodes. Popular, actively maintained nodes are more reliable. When in doubt: test the node in a separate flow before adding it to a production flow.

With the dashboard node package (@flowfuse/node-red-dashboard), build custom web interfaces — without writing HTML, CSS, or JavaScript.

• Production dashboard: Sensor values, machine status, alarms at a glance
• Support dashboard: Current ticket counts from Zammad, uptime status, open tasks
• Association dashboard: Next events, membership numbers, weather for the next outdoor event
• Input form: Internal form for requesting time off → triggers email to HR

Dashboard as a mini-app

The dashboard is accessible via its own URL (e.g. https://your-nodered.srv.camp/ui). Bookmark it in the browser or add it as a web app on your phone. A simple dashboard — no separate app development needed.

When you need the same process in multiple flows (e.g. “format error and send to Mattermost”), encapsulate it as a subflow.

Useful subflow examples:

• “Send to Mattermost” — accepts text and posts to a configurable channel
• “Error handler” — catches errors, formats them, sends notification
• “API authentication” — fetches a token, caches it, adds it to requests
• “Validate record” — checks whether all required fields are present

A subflow behaves like its own node — drag it from the palette into a flow and configure it through parameters.

Node-RED provides catch nodes that intercept errors from other nodes. Without error handling, flows fail silently — you only notice when results stop arriving.

1. Add at least one catch node to every production flow
2. Connect the catch node to:
   • A debug node (for logging)
   • A notification (email or Mattermost) that alerts you to the error
3. For HTTP webhooks: add an http response node in the error case so the sender doesn’t wait indefinitely

Status nodes show the current state of individual nodes in the flow editor (e.g. “Connected”, “Waiting for data”, “Error”). Ideal for nodes that maintain persistent connections (MQTT, databases, WebSockets).

Flows can be exported and imported as JSON:

1. Select a flow or all flows → Menu → Export → Clipboard or Download file
2. The JSON can be imported into a new Node-RED → Menu → Import

Back up flows regularly

Save important flows as JSON backups in Nextcloud or Seafile, or use a Git repository in GitLab. server.camp includes daily backups, but your own versioned backup lets you restore older versions of a flow.

Sharing flows

Node-RED has a community library at flows.nodered.org where thousands of flows and nodes are shared. Before building a flow from scratch, check there first — a template you can adapt often already exists.

Tip for freelancers: Node-RED is ideal for closing the gaps between your tools. You use a CRM, a calendar, a mail server, and cloud storage — Node-RED connects them all and eliminates daily repetitive manual work.

Tip for SMBs: Start by automating whatever saves the most manual effort.

Tip for associations: The dashboard feature is especially valuable: create a simple association dashboard with upcoming events and important links — accessible via a URL, no app development required.

Node-RED is the ideal connector between all your server.camp services:

Node-RED as a central integration hub

In organizations using Nextcloud, Zammad, Mattermost, Uptime Kuma, Paperless-ngx, and other tools, Node-RED is the connecting element. It receives webhooks from all systems and can trigger actions in all others. Instead of connecting each system to every other system individually, everything flows through Node-RED as a central hub.

Node-RED at server.camp is accessible via your personal URL and protected with username/password. Keep your credentials secure. On the Corporate plan, SSO via OpenID Connect can be configured — contact support for help.

Your webhook URLs are publicly reachable. To prevent abuse:

• Shared secret: Send a secret token in the header and verify it in the flow
• IP whitelist: Check in the flow whether the request comes from a known IP
• HMAC verification: Many systems (GitHub, Stripe) sign webhooks — verify the signature in the flow

Always secure webhooks

Without protection, anyone who knows your webhook URL can send data to your flow. Implement at least a shared secret and verify it in the flow with a switch node.

Need help setting up a flow or implementing a more complex automation? Reach out at support@server.camp. We’re happy to help.

Find frequently asked questions about Node-RED on our product page.