Node-RED & Python: Send Data Easily

Nov 18, 2025 by Alex Braham 36 views

Introduction

Hey guys! Ever wondered how to get your Node-RED flows talking to your Python scripts? You're in the right place! This guide will walk you through the nitty-gritty of sending data from Node-RED to Python, making your automation projects supercharged. We'll cover everything from setting up the necessary tools to crafting the perfect data exchange. So, buckle up, and let's dive in!

Why Send Data from Node-RED to Python?

Before we jump into the how-to, let's chat about the why. Node-RED excels at visual programming, making it a breeze to create workflows for IoT devices, APIs, and more. Python, on the other hand, is a powerhouse for data analysis, machine learning, and complex logic. Combining these two can unlock incredible potential. Imagine using Node-RED to collect sensor data and then passing it to Python for real-time analysis or using Node-RED to trigger Python scripts that perform specific tasks based on incoming data. The possibilities are endless!

Use Cases

IoT Data Processing: Collect data from sensors using Node-RED and send it to Python for analysis and visualization.
Machine Learning Integration: Trigger Python-based machine learning models from Node-RED flows for real-time predictions.
API Interactions: Use Node-RED to manage API calls and send the results to Python for further processing or transformation.
Custom Logic: Offload complex calculations or custom logic to Python scripts triggered by Node-RED events.

Prerequisites

Before we start, make sure you have the following:

Node-RED: Installed and running. If you haven't already, you can install it using npm: npm install -g node-red
Python: Installed and accessible. Make sure Python is added to your system's PATH.
Node-RED Nodes: node-red-node-exec and node-red-node-http-request (or similar nodes for HTTP requests). You can install these from the Node-RED palette manager.

Methods for Sending Data

There are several ways to send data from Node-RED to Python, each with its own pros and cons. We'll explore a few popular methods:

1. Using the Exec Node

The exec node allows you to execute shell commands directly from your Node-RED flow. This is a straightforward way to run a Python script and pass data as command-line arguments or via standard input.

Example

Create a Python script (e.g., process_data.py) that reads data from standard input or command-line arguments.

import sys
import json

# Read data from stdin
data = json.loads(sys.stdin.read())

# Process the data
processed_data = {
    "message": f"Received: {data['payload']['message']}",
    "timestamp": data['payload']['timestamp']
}

# Print the processed data to stdout
print(json.dumps(processed_data))

In Node-RED, add an inject node to generate some data.

{
    "payload": {
        "message": "Hello from Node-RED!",
        "timestamp": "2024-01-01T12:00:00Z"
    }
}

Connect the inject node to an exec node. Configure the exec node to execute the Python script with the data piped into it.
- Command: python /path/to/process_data.py
- Append payload to command: Uncheck this box.
Connect the exec node to a debug node to view the output.

Pros

Simple and direct.
No need for additional libraries or services.

Cons

Can be less efficient for large data volumes.
Error handling can be tricky.
Security considerations when executing arbitrary commands.

2. Using HTTP Requests

Another common method is to set up a simple HTTP server in Python using frameworks like Flask or FastAPI. Node-RED can then send data to this server using an http request node.

Example

Create a Python web server (e.g., using Flask).

from flask import Flask, request, jsonify

app = Flask(__name__)

@app.route('/process_data', methods=['POST'])
def process_data():
    data = request.get_json()
    # Process the data
    processed_data = {
        "message": f"Received: {data['payload']['message']}",
        "timestamp": data['payload']['timestamp']
    }
    return jsonify(processed_data)

if __name__ == '__main__':
    app.run(debug=True, host='0.0.0.0', port=5000)

In Node-RED, add an inject node to generate some data.

{
    "payload": {
        "message": "Hello from Node-RED!",
        "timestamp": "2024-01-01T12:00:00Z"
    }
}

Connect the inject node to an http request node. Configure the http request node to send a POST request to the Python server.
- Method: POST
- URL: http://localhost:5000/process_data
- Content-type: application/json
- Payload: msg.payload
Connect the http request node to a debug node to view the output.

Pros

More scalable and robust than using the exec node.
Easier to handle complex data structures.
Clear separation of concerns between Node-RED and Python.

Cons

Requires setting up and managing a web server.
Adds complexity to the project.

3. Using MQTT

MQTT (Message Queuing Telemetry Transport) is a lightweight messaging protocol that's perfect for IoT applications. You can use an MQTT broker to facilitate communication between Node-RED and Python.

Example

Install an MQTT broker (e.g., Mosquitto).

In Python, use a library like paho-mqtt to subscribe to an MQTT topic and process incoming messages.

import paho.mqtt.client as mqtt
import json

def on_connect(client, userdata, flags, rc):
    print("Connected with result code " + str(rc))
    client.subscribe("nodered/data")

def on_message(client, userdata, msg):
    data = json.loads(msg.payload.decode())
    # Process the data
    processed_data = {
        "message": f"Received: {data['payload']['message']}",
        "timestamp": data['payload']['timestamp']
    }
    print(processed_data)

client = mqtt.Client()
client.on_connect = on_connect
client.on_message = on_message

client.connect("localhost", 1883, 60)

client.loop_forever()

In Node-RED, use the mqtt out node to publish data to the MQTT topic.
- Server: localhost (or the address of your MQTT broker)
- Topic: nodered/data
- QoS: 0 or 1

Connect an inject node to the mqtt out node to send data.

{
    "payload": {
        "message": "Hello from Node-RED!",
        "timestamp": "2024-01-01T12:00:00Z"
    }
}

Pros

Decoupled communication between Node-RED and Python.
Scalable and reliable.
Suitable for distributed systems.

Cons

Requires setting up and managing an MQTT broker.
Adds complexity to the project.

Step-by-Step Example: Using HTTP Requests with Flask

Let's walk through a complete example using HTTP requests and Flask. This is a great way to get started with sending data between Node-RED and Python.

1. Set Up the Flask Server

Create a Python file (e.g., app.py) with the following code:

from flask import Flask, request, jsonify

app = Flask(__name__)

@app.route('/process_data', methods=['POST'])
def process_data():
    data = request.get_json()
    print(f"Received data: {data}")

    # Process the data (example)
    processed_data = {
        "message": f"Data received and processed!",
        "original_data": data
    }

    return jsonify(processed_data)

if __name__ == '__main__':
    app.run(debug=True, host='0.0.0.0', port=5000)

This code sets up a simple Flask server that listens for POST requests on the /process_data endpoint. When it receives data, it prints it to the console and returns a JSON response.

2. Run the Flask Server

Open a terminal, navigate to the directory containing app.py, and run the server:

python app.py

You should see output indicating that the server is running on http://0.0.0.0:5000.

3. Create the Node-RED Flow

Open Node-RED in your browser.

Add an inject node to generate some data.

{
    "payload": {
        "sensor_id": "sensor123",
        "temperature": 25.5,
        "humidity": 60.2
    }
}

Add an http request node and connect it to the inject node.
- Method: POST
- URL: http://localhost:5000/process_data
- Content-type: application/json
- Name: Send to Python
Add a debug node and connect it to the http request node to view the response.

4. Deploy and Test the Flow

Click the Deploy button in Node-RED.
Click the button on the inject node to send the data.
Check the debug tab in Node-RED to see the response from the Flask server.
Check the console where you ran the Flask server to see the data that was received.

Error Handling

When sending data between Node-RED and Python, it's essential to handle errors gracefully. Here are some tips:

In Node-RED, use catch nodes to handle exceptions and errors.
In Python, use try...except blocks to catch exceptions.
Log errors to a file or database for later analysis.
Return meaningful error messages from your Python scripts to Node-RED.

Security Considerations

When sending data between Node-RED and Python, keep security in mind:

Validate input data to prevent injection attacks.
Use HTTPS for secure communication between Node-RED and your Python server.
Limit access to your Python server to only authorized clients.
Avoid executing arbitrary commands using the exec node.

Conclusion

Alright, folks! You've now got the knowledge to send data from Node-RED to Python using various methods. Whether you choose the simplicity of the exec node, the robustness of HTTP requests, or the scalability of MQTT, you're well-equipped to integrate these powerful tools. So go forth, experiment, and build amazing automation solutions!

Happy coding, and remember to always validate your inputs! By leveraging both Node-RED and Python, you can create some seriously cool stuff. Now, go make it happen!