How can I trigger an n8n workflow using an HTTP POST request?

Dev

To trigger an n8n workflow using an HTTP POST request, you can use the Webhook Trigger node in your workflow. Here’s how to set it up step by step:

✅ Step 1: Add a Webhook Trigger Node

In your n8n workflow, drag and drop the "Webhook" node.
Set the HTTP Method to POST.

Choose a Path, for example: /my-webhook.

This makes your webhook URL like:

   https://<your-n8n-domain>/webhook/my-webhook

(For testing on localhost, it might be: http://localhost:5678/webhook/my-webhook)

✅ Step 2: Save and Activate the Workflow

Click Save.
Set the workflow to Active (top right corner).
- Only active workflows respond to external HTTP requests.

✅ Step 3: Send a POST Request

You can now send a POST request to the webhook. For example, using cURL:

curl -X POST https://<your-n8n-domain>/webhook/my-webhook \
  -H "Content-Type: application/json" \
  -d '{"name": "John", "email": "john@example.com"}'

Or using JavaScript (fetch):

fetch("https://<your-n8n-domain>/webhook/my-webhook", {
  method: "POST",
  headers: {
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    name: "John",
    email: "john@example.com"
  })
});

✅ Step 4: Access the POST Data in n8n

In your workflow, the Webhook node will output the data in:

{{ $json["body"] }} — The POST body
{{ $json["headers"] }} — Request headers

Use this data in the next nodes (e.g., send email, insert into DB, etc.).

✅ Optional: Test Webhook

If your workflow is not active, use the "Test" button in n8n. It gives you a test URL that looks like:

https://<your-n8n-domain>/webhook-test/my-webhook

Let me know if you want to secure the webhook with a secret token or set up authentication headers.

Dev

To trigger an n8n workflow using an HTTP POST request, you'll need to use a Webhook node as the trigger. Here's how to set it up:

Setting up the Webhook Trigger

Add a Webhook node to your workflow as the first node
Configure the Webhook node:
- Set the HTTP Method to POST
- Choose between:
  - Production URL: For live workflows (webhook stays active)
  - Test URL: For testing (temporary, expires after workflow execution)
Save and activate your workflow

Making the HTTP POST Request

Once configured, n8n will provide you with a webhook URL that looks like:

https://your-n8n-instance.com/webhook/your-webhook-path

You can then send POST requests to this URL using:

curl:

curl -X POST https://your-n8n-instance.com/webhook/your-webhook-path \
  -H "Content-Type: application/json" \
  -d '{"key": "value", "message": "Hello n8n"}'

JavaScript:

fetch('https://your-n8n-instance.com/webhook/your-webhook-path', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    key: 'value',
    message: 'Hello n8n'
  })
});

Accessing POST Data

In subsequent nodes, you can access the POST data using expressions:

{{ $json.key }} - for JSON payload data
{{ $node["Webhook"].json["key"] }} - explicit node reference
Headers: {{ $node["Webhook"].json["headers"] }}
Query parameters: {{ $node["Webhook"].json["query"] }}

Authentication Options

For security, you can add authentication to your webhook:

Basic Auth: Set username/password in the Webhook node
Header Auth: Require specific headers
Query Auth: Require authentication via query parameters

The workflow will execute automatically whenever it receives a POST request to the webhook URL, making it perfect for integrations with external systems, forms, or APIs.

Dev

To trigger an n8n workflow using an HTTP POST request, you'll primarily use the Webhook trigger node within your n8n workflow. Here's a step-by-step guide:

1. Create a New Workflow in n8n:

Open your n8n instance and click "New" to create a new workflow.

2. Add a Webhook Trigger Node:

Search for "Webhook" in the nodes panel and drag the Webhook node onto your canvas.

3. Configure the Webhook Node:

Webhook URL: When you add the Webhook node, n8n will automatically generate a unique URL for it. This is the URL you'll send your POST requests to. You can find it displayed prominently on the node.
HTTP Method: By default, it's set to "GET". Change this to "POST" since you want to trigger it with a POST request.
Authentication (Optional but Recommended):
- Header Auth: You can add a custom header (e.g., Authorization: Bearer YOUR_SECRET_TOKEN) and configure the Webhook node to expect this header for authentication.
  - Query Auth: You can also add parameters to the URL (e.g., ?apiKey=YOUR_SECRET_KEY).
  - Basic Auth: n8n also supports basic authentication.
  - No Auth: While easiest for testing, it's generally not recommended for production environments as anyone with the URL could trigger your workflow.
Response (Optional): You can configure what n8n should respond with after receiving the webhook. This can be a custom message, the data it received, or nothing.

4. Activate Your Workflow:

Once you've configured the Webhook node and any subsequent nodes in your workflow, make sure to activate your workflow by toggling the "Active" switch in the top right corner. This makes the webhook URL live and ready to receive requests.

5. Send an HTTP POST Request:

Now you need to send an HTTP POST request to the Webhook URL. You can do this using various tools:

cURL (Command Line): This is a common and versatile way.
```
    curl -X POST -H "Content-Type: application/json" -d '{"key1": "value1", "key2": "value2"}' YOUR_WEBHOOK_URL
```
- Replace YOUR_WEBHOOK_URL with the actual URL from your Webhook node.
  - -X POST: Specifies the HTTP POST method.
  - -H "Content-Type: application/json": Tells the server that you're sending JSON data. Adjust if you're sending other content types (e.g., application/x-www-form-urlencoded).
  - -d '{"key1": "value1", "key2": "value2"}': This is your JSON payload. You can send any valid JSON structure.
Postman/Insomnia (API Clients):
1. Create a new request.
2. Set the method to POST.
3. Enter your Webhook URL in the URL field.
4. Go to the "Body" tab and choose "raw" and "JSON" (or "form-urlencoded" if applicable).
5. Enter your JSON data.
6. Click "Send".

Programming Languages (Python Example):

    import requests
    import json

    webhook_url = "YOUR_WEBHOOK_URL"
    payload = {
        "name": "John Doe",
        "email": "john.doe@example.com",
        "message": "Hello from Python!"
    }
    headers = {
        "Content-Type": "application/json"
    }

    response = requests.post(webhook_url, data=json.dumps(payload), headers=headers)

    print(f"Status Code: {response.status_code}")
    print(f"Response Body: {response.text}")

Web Forms (HTML):

    <form action="YOUR_WEBHOOK_URL" method="POST">
        <label for="name">Name:</label><br>
        <input type="text" id="name" name="name"><br>
        <label for="message">Message:</label><br>
        <textarea id="message" name="message"></textarea><br><br>
        <input type="submit" value="Submit">
    </form>

Note: This will send application/x-www-form-urlencoded data by default.

6. Process the Data in n8n:

Once the Webhook node receives a POST request, the data sent in the request body will be available in subsequent nodes within your n8n workflow.
You can access this data using expressions like {{ $json.keyName }} or {{ $json["keyName"] }} if the body is JSON. If it's form-urlencoded, you might access it via {{ $node["Webhook"].json.name }} (where name is the input field name).

Important Considerations:

Content-Type Header: Ensure the Content-Type header in your POST request matches the type of data you are sending (e.g., application/json, application/x-www-form-urlencoded, text/plain).
JSON Structure: If you're sending JSON, make sure it's valid JSON.
Error Handling: In your n8n workflow, consider adding error handling nodes (e.g., "If" nodes to check for specific data, "Try/Catch" nodes) to gracefully handle unexpected input or issues.
Security: Always use authentication for production webhooks to prevent unauthorized access and triggering of your workflows.
Testing: Use the "Execute Workflow" button in n8n and tools like Postman or cURL to thoroughly test your webhook setup before deploying it.

By following these steps, you can effectively trigger your n8n workflows using HTTP POST requests, enabling powerful integrations with various external systems and applications.

Dev

To trigger an n8n workflow using an HTTP POST request, follow these steps:

Add a Webhook Node: In your n8n workflow, include a Webhook node as the starting point. This node listens for incoming HTTP requests.
Configure the Webhook Node:
- Open the Webhook node settings in n8n.
- Set the HTTP Method to POST.
- Note the Webhook URL provided by n8n (e.g., https://your-n8n-instance.com/webhook/12345678-1234-1234-1234-1234567890ab). This is the endpoint you'll send the POST request to.
- Optionally, configure authentication (e.g., Basic Auth, API Key) or other settings like response format or headers if needed.

Test the Webhook:

Activate the workflow in Test mode to get a test Webhook URL.

Send a POST request to the test URL using a tool like curl, Postman, or your application code. For example:

     curl -X POST https://your-n8n-instance.com/webhook-test/12345678-1234-1234-1234-1234567890ab \
     -H "Content-Type: application/json" \
     -d '{"key": "value"}'

Verify that the Webhook node receives the data and triggers the workflow.

Activate the Workflow:
- Once tested, switch the workflow to Production mode (toggle "Active" in n8n).
- Use the production Webhook URL (remove -test from the URL) for your POST requests.

Send the POST Request:

From your application or script, send the HTTP POST request to the production Webhook URL with the required payload. Example in JavaScript (using fetch):

     fetch('https://your-n8n-instance.com/webhook/12345678-1234-1234-1234-1234567890ab', {
       method: 'POST',
       headers: {
         'Content-Type': 'application/json'
       },
       body: JSON.stringify({ key: 'value' })
     })
     .then(response => response.json())
     .then(data => console.log(data))
     .catch(error => console.error('Error:', error));

Handle the Payload in n8n:
- The Webhook node will receive the POST request's body (e.g., JSON data) and pass it to subsequent nodes in the workflow.
- Use nodes like "Set" or "Function" to process the incoming data as needed.

Notes:

Ensure your n8n instance is accessible (e.g., hosted publicly or behind a secure network with proper firewall settings).
If authentication is enabled, include credentials in the POST request (e.g., API key in headers or Basic Auth).
For security, use HTTPS and consider restricting the Webhook to specific IPs or adding a secret token.

For more details, check the n8n documentation at https://docs.n8n.io/integrations/builtin/core-nodes/n8n-nodes-base.webhook/.