HTTP Requests

The HTTP Request node allows you to connect to any REST API, enabling custom integrations with external services.

Overview

Use HTTP Request nodes to:

• Fetch data from external APIs
• Send data to webhooks and services
• Enrich records with third-party information
• Trigger actions in external systems

Node Configuration

Basic Settings

HTTP Methods

Setting Up a Request

Step 1: Add the Node

1. Drag HTTP Request from the sidebar onto your automation
2. Connect an input source (optional - for dynamic URLs)
3. Click the node to configure

Step 2: Configure the URL

Enter the API endpoint. You can use dynamic values from input data:

Static URL:

https://api.example.com/users

Dynamic URL with record data:

https://api.example.com/users/{{user_id}}

Template syntax: {{column_name}} — reference top-level record fields directly, with no prefix. Only \w+ identifiers (letters, digits, underscores) are matched, so rename fields with hyphens upstream first. See Template Syntax for the full reference.

Step 3: Set Headers

Add headers for authentication and content type:

Common headers:

Step 4: Configure the Body

For POST, PUT, and PATCH requests, define the request body:

Static JSON:

{
  "action": "lookup",
  "include_details": true
}

Dynamic JSON with record data:

{
  "email": "{{email}}",
  "company": "{{company_name}}"
}

Step 5: Map the Response

Define how to extract data from the API response:

1. Response preview: Run a test request to see the response structure
2. Field mapping: Select which fields to include in output
3. Path notation: Use dot notation for nested fields (data.user.name)

Authentication Examples

Bearer Token

Headers:
  Authorization: Bearer eyJhbGciOiJIUzI1NiIs...

API Key in Header

Headers:
  X-API-Key: your-api-key-here

API Key in URL

URL: https://api.example.com/data?api_key=your-api-key

Basic Auth

Headers:
  Authorization: Basic base64(username:password)

Response Handling

Successful Responses

When the API returns 2xx status:

• Response body is parsed (JSON automatically detected)
• Mapped fields are added to the output record
• Processing continues to next node

Error Responses

When the API returns 4xx or 5xx status:

Response Mapping Examples

Flat response:

{
  "name": "Acme Corp",
  "revenue": 1000000
}

Mapping: name, revenue

Nested response:

{
  "data": {
    "company": {
      "name": "Acme Corp",
      "metrics": {
        "revenue": 1000000
      }
    }
  }
}

Mapping: data.company.name, data.company.metrics.revenue

Array response:

{
  "results": [
    {"id": 1, "value": "a"},
    {"id": 2, "value": "b"}
  ]
}

Mapping: results[0].value or expand array to multiple records

Advanced Features

Pagination

For APIs that return paginated results, drive the pages from your automation: request a page, extract the next-page token or offset from the response, and feed it back into a follow-up request. Combine the HTTP node with flow-control nodes (such as Poll or a Condition loop) to walk through pages until the API signals there are no more.

Rate Limiting

When an upstream API returns 429 (Too Many Requests), the node treats it as a transient error and retries with exponential backoff. External APIs enforce their own limits — when processing many records, batch your requests where possible to stay within them.

Timeout

The node uses a single configurable request timeout, defaulting to 30 seconds. Set the timeout field (in milliseconds) on the node to override it.

Retry Configuration

Transient failures are retried automatically:

Common Patterns

Enrichment Pattern

Fetch additional data for each record:

[Your Data] → [HTTP Request] → [Enriched Output]
     ↓              ↓
 customer_id   GET /customers/{{customer_id}}

Batch Lookup Pattern

Send multiple items in one request:

[Your Data] → [HTTP Request] → [Parse Response]
                   ↓
            POST /batch-lookup
            Body: {"ids": [all record IDs]}

Webhook Pattern

Send results to an external system:

[Processed Data] → [HTTP Request]
                        ↓
                   POST /webhook
                   Body: {"id": "{{id}}", "status": "{{status}}"}

Best Practices

Security

• Never hardcode credentials in URLs or bodies
• Use HTTPS for all requests
• Validate responses before using data
• Limit permissions of API keys

Performance

• Batch when possible: Fewer requests are faster
• Cache responses: Don't re-fetch static data
• Set appropriate timeouts: Balance between reliability and speed
• Filter before requesting: Only fetch data you need

Reliability

• Handle errors gracefully: Define fallback behavior
• Log requests: Enable logging for debugging
• Monitor rate limits: Stay well under limits
• Test thoroughly: Verify with realistic data

Troubleshooting

Request Fails Immediately

• Verify URL is correct and accessible
• Check for typos in headers
• Ensure authentication is correct
• Test the same request in a tool like Postman

Timeout Errors

• Increase timeout settings
• Check if API is responding slowly
• Reduce payload size if possible

Unexpected Response Data

• Verify response mapping paths
• Check for null or missing fields
• Ensure response content type is correct

Rate Limit Errors

• Reduce concurrent requests
• Enable automatic rate limiting
• Contact API provider for higher limits