How do I send data from one API to another using n8n?

Dev

To send data from one API to another using n8n, you can chain together HTTP Request nodes (or a Webhook trigger + HTTP request) to receive, process, and forward data. Here's a full example:

✅ Scenario Example

Goal: Receive a POST request from API A → forward specific data to API B.

🔧 Step-by-Step Setup

1. Trigger: Receive data from API A

Use a Webhook node:

Method: POST
Path: receive-data

This gives you an endpoint like:

    https://<your-n8n-domain>/webhook/receive-data

2. Add a "Set" Node (optional)

Use the Set node to extract or reshape the data as needed:
- Click "Add Field"
- Example:
- Name: name, Value: {{$json["body"]["name"]}}
- Name: email, Value: {{$json["body"]["email"]}}

3. Send to API B using "HTTP Request" node

Use the HTTP Request node to send data to API B:

Method: POST
URL: (e.g.) https://api.example.com/users
Authentication: (Set if needed: Bearer token, Basic Auth, etc.)
Body Content Type: JSON

JSON/Raw Parameters:

    {
      "name": "={{$json["name"]}}",
      "email": "={{$json["email"]}}"
    }

🔁 Optional: Handle API B’s Response

Connect a "Function" or "IF" node after the HTTP request to:
- Log or filter the result
- Trigger follow-up actions (email, Slack, etc.)

✅ Example Workflow Overview

[Webhook Trigger] → [Set Data] → [HTTP Request to API B] → [Optional Logging or Alert]

🧪 Test It

Set the workflow to Active.
Send a test POST to https://<your-n8n-domain>/webhook/receive-data.
Watch the data flow through the workflow in the Execution view.

Sending data from one API to another using n8n is a core functionality and relatively straightforward. You'll primarily use the HTTP Request node for both fetching data from the first API and sending it to the second.

Here's a breakdown of the process:

1. Workflow Structure

A typical workflow for this scenario will look something like this:

Trigger Node: This is how your workflow starts. It could be:
- Webhook: If the first API sends data to n8n.
  - HTTP Request: If n8n needs to proactively fetch data from the first API (e.g., a GET request).
  - Schedule: To fetch data at regular intervals.
  - Another application-specific trigger: If you're integrating with a service that has a dedicated n8n node (e.g., a "New Email" in Gmail, a "New Row" in Google Sheets).
HTTP Request Node (API 1 - Fetch Data): This node will make the call to your first API to retrieve the data you need.
Data Transformation/Manipulation Nodes (Optional but Common): After getting data from API 1, you might need to:
- Set Node: To rename fields, add new fields, or filter out unnecessary data.
  - Code Node: For more complex data manipulation using JavaScript.
  - Split In Batches Node: If the data from API 1 is a large array and API 2 expects individual items or smaller batches.
  - Merge Node: If you need to combine data from multiple sources or prior steps.
HTTP Request Node (API 2 - Send Data): This node will send the processed data to your second API.

2. Step-by-Step Guide

Let's assume you need to fetch data from "API A" and send it to "API B".

A. Triggering the Workflow & Fetching from API A

Add a Trigger Node:
- If API A sends data to n8n: Use a Webhook node. Configure it to listen for the appropriate HTTP method (GET, POST, etc.) and copy its URL. This is the URL API A will call.
  - If n8n fetches data from API A: Use an HTTP Request node as your trigger (if it's a simple, one-off fetch or scheduled). Or, use a Schedule node followed by an HTTP Request node to periodically pull data.
Configure the HTTP Request Node for API A:
- Drag an HTTP Request node onto your canvas (if it's not your trigger).
  - Authentication: Set up the necessary authentication for API A (e.g., API Key, OAuth2, Basic Auth, or None). n8n has various credential types.
  - HTTP Method: Select the method required by API A (e.g., GET for retrieving data, POST if you need to send some initial parameters).
  - URL: Enter the endpoint for API A.
  - Headers/Parameters/Body: Add any required headers, query parameters, or request body according to API A's documentation.
  - Execute the node (or the whole workflow if using a trigger) to see the data API A returns. This is crucial for understanding its structure.

B. Preparing Data for API B (Transformation)

Inspect the Output: After running the HTTP Request node for API A, check the output in the n8n editor. This shows you the exact JSON structure of the data you received.
Add Data Transformation Nodes (if needed):
- Set Node: This is your go-to for simple data manipulation.
  - To select specific fields: Add properties and use expressions like {{ $json.data.someField }} to map them to new field names.
    - To add static values: Just type them in.
    - To remove unwanted fields: Use the "Remove" operation.
  - Code Node: If you need more complex logic, filtering, or restructuring that the Set node can't handle. You'll write JavaScript code to transform item.json and return the modified item.json.
  - Split In Batches / Item Lists Node: If API A returns an array of many items, and API B expects them one by one or in smaller chunks, use these nodes to control the flow.

C. Sending Data to API B

Add another HTTP Request Node for API B:
- Drag a new HTTP Request node onto your canvas and connect it after your data preparation steps.
  - Authentication: Configure the authentication for API B.
  - HTTP Method: Set the method required by API B (often POST or PUT for sending data).
  - URL: Enter the API B endpoint.
  - Headers/Parameters: Add any specific headers or query parameters API B requires.
Construct the Request Body for API B:
- This is the most critical part. You'll use expressions to insert data from previous nodes into the request body for API B.
  - In the "Body" section of the HTTP Request node:
    - Set "Body Content Type" (e.g., "JSON," "Form Data," "Raw"). JSON is very common.
    - If JSON, select "Raw" and "JSON" and then start typing your JSON structure.
    - To insert data from a previous node, use expressions. For example, if your previous node output {"name": "John", "email": "john@example.com"}, you might create a JSON body like:
```
            {
              "customer_name": "{{ $json.name }}",
              "customer_email": "{{ $json.email }}",
              "source": "n8n_integration"
            }
```
      - {{ $json.name }} refers to the name property of the current item's JSON data.
      - You can use the expression editor (the little cogwheel icon next to input fields) to browse available data from previous nodes.
Error Handling (Highly Recommended):
- Add an If node after the HTTP Request for API B to check its response status code (e.g., {{ $json.statusCode }} for success or error codes).
  - Add Error Trigger and Error Handler workflows to catch unexpected issues and send notifications (e.g., to Slack, email) or retry operations.

D. Saving and Activating

Save Your Workflow: Give it a meaningful name.
Activate Your Workflow: Toggle the "Active" switch in the top right. Your workflow is now live and will execute when its trigger is activated.

Key Concepts in n8n for Data Flow:

Items: n8n workflows process data in "items." Each item represents a piece of data flowing through the workflow. Nodes typically operate on each incoming item.
JSON Data: The primary data format within n8n is JSON.
Expressions: These are powerful tools that allow you to dynamically access and manipulate data from previous nodes. They start with {{ and end with }}.
- {{ $json.propertyName }}: Access a property from the current item's JSON data.
  - {{ $node["Node Name"].json.propertyName }}: Access a property from a specific previous node's output.
  - {{ $node["Node Name"].json }}: Access the entire JSON output of a specific previous node.
  - {{ $items("Node Name")[0].json.propertyName }}: Access data from a specific item (e.g., the first item) from a previous node.
Binary Data: For file uploads (e.g., sending an image from one API to another), n8n handles binary data. The HTTP Request node has options for sending "Form Data (multipart/form-data)" which allows you to include binary files.

By understanding these components and how data flows through n8n, you can build powerful and flexible integrations between virtually any APIs. Always refer to the API documentation of both your source and destination APIs to ensure you're sending and receiving data in the correct format and with the proper authentication.