HTTP Request

Makes HTTP requests to any URL with full control over method, auth, headers, body, and response handling.

Overview

Universal HTTP client tool for making configurable HTTP requests to any URL. Supports GET, POST, PUT, PATCH, DELETE, HEAD, and OPTIONS methods. Handles authentication via Basic Auth, Bearer Token, Header Auth, Query Auth, and custom auth. Supports JSON, form-urlencoded, multipart form-data, and raw request bodies. Configurable pagination (parameter update per request, next-URL-in-response), batching with rate limiting, redirect control, timeout, proxy, and SSL settings. Response can be parsed as JSON, text, or auto-detected. This is the go-to tool when no dedicated integration exists for a service.

Category: Core Nodes
Tool Name: http_request
Version: 1

Appearance: Icon: webhook | Color: #0004F5

Node Type

Action — processes input items and produces output

Input / Output

Direction	Port(s)
Input	Input
Output	Output, Error

Credentials

This tool supports Basic Auth, Bearer Token, Header Auth and Query Auth credentials. See the Credentials Guide for setup instructions.

Authentication is optional: leave Authentication set to none for a public endpoint and no credential is needed. When you do authenticate, choose the method in Authentication and store the secret as a credential of the matching type. A configured credential takes precedence over the equivalent fields entered directly on the node, so you can develop with inline values and switch to a stored credential later without changing anything else.

Parameters

Request

Parameter	Type	Required	Default	Description
Method	options	No	GET	The HTTP method to use for the request.
				Options: DELETE, GET, HEAD, OPTIONS, PATCH, POST, PUT
URL	string	Yes	—	The URL to make the request to. Must start with http:// or https://. Supports expressions like {{ $json.endpoint }}.
Authentication	options	No	none	The authentication method to use. Select “None” for public APIs.
				Options: none, httpBasicAuth, httpBearerToken, httpHeaderAuth, httpQueryAuth, customAuth

Authentication Fields

Parameter	Type	Required	Default	Description
Username	string	Yes	—	The username for Basic Auth. (shown when Authentication is httpBasicAuth)
Password	string	Yes	—	The password for Basic Auth. (shown when Authentication is httpBasicAuth)
Token	string	Yes	—	The bearer token to include in the Authorization header. (shown when Authentication is httpBearerToken)
Header Name	string	Yes	Authorization	The name of the authentication header. (shown when Authentication is httpHeaderAuth)
Header Value	string	Yes	—	The value of the authentication header. (shown when Authentication is httpHeaderAuth)
Query Parameter Name	string	Yes	api_key	The name of the query parameter used for authentication. (shown when Authentication is httpQueryAuth)
Query Parameter Value	string	Yes	—	The value of the query parameter used for authentication. (shown when Authentication is httpQueryAuth)
Custom Auth Headers	fixedCollection	No	One empty header	Custom headers to include for authentication. (shown when Authentication is customAuth)
— Name	string	No	—	The header name.
— Value	string	No	—	The header value.

Query Parameters

Parameter	Type	Required	Default	Description
Send Query Parameters	boolean	No	false	Whether to include query parameters in the request URL.
Specify Query Parameters	options	No	keypair	How to specify the query parameters. (shown when Send Query Parameters is true)
				Options: keypair (using the fields below), json (using a JSON object)
Query Parameters	fixedCollection	No	One empty pair	Key-value pairs to include as query parameters. (shown when Send Query Parameters is true and Specify Query Parameters is keypair)
— Name	string	No	—	The parameter name.
— Value	string	No	—	The parameter value.
JSON Query	json	No	—	Query parameters as a JSON object. (shown when Send Query Parameters is true and Specify Query Parameters is json)

Headers

Parameter	Type	Required	Default	Description
Send Headers	boolean	No	false	Whether to include custom headers in the request.
Specify Headers	options	No	keypair	How to specify the headers. (shown when Send Headers is true)
				Options: keypair (using the fields below), json (using a JSON object)
Headers	fixedCollection	No	One empty pair	Key-value pairs to include as HTTP headers. (shown when Send Headers is true and Specify Headers is keypair)
— Name	string	No	—	The header name.
— Value	string	No	—	The header value.
JSON Headers	json	No	—	Headers as a JSON object. (shown when Send Headers is true and Specify Headers is json)

Body

Parameter	Type	Required	Default	Description
Send Body	boolean	No	false	Whether to include a body in the request.
Body Content Type	options	No	json	The content type of the request body. (shown when Send Body is true)
				Options: json, form-urlencoded, multipart-form-data, raw
Specify Body (specifyBody)	options	No	keypair	How to specify the JSON body. (shown when Send Body is true and Body Content Type is json)
				Options: keypair (using the fields below), json (using a JSON object)
Body Parameters	fixedCollection	No	One empty pair	Key-value pairs to include in the JSON body. (shown when Send Body is true, Body Content Type is json and Specify Body is keypair)
— Name	string	No	—	Field name. Supports dot notation for nested fields (e.g. “data.name”).
— Value	string	No	—	Field value.
JSON Body	json	No	—	The request body as a JSON object. (shown when Send Body is true, Body Content Type is json and Specify Body is json)
Specify Body (specifyBodyUrlEncoded)	options	No	keypair	How to specify the form-urlencoded body. (shown when Send Body is true and Body Content Type is form-urlencoded)
				Options: keypair (using the fields below), string (one raw field)
Body Parameters (URL-Encoded)	fixedCollection	No	One empty pair	Key-value pairs for form-urlencoded body. (shown when Send Body is true, Body Content Type is form-urlencoded and Specify Body is keypair)
— Name	string	No	—	The field name.
— Value	string	No	—	The field value.
Body (body)	string	No	—	Raw URL-encoded body string. (shown when Send Body is true, Body Content Type is form-urlencoded and Specify Body is string)
Body Parameters (Multipart)	fixedCollection	No	One empty pair	Key-value pairs for multipart form-data body. Binary file uploads are not yet supported. (shown when Send Body is true and Body Content Type is multipart-form-data)
— Name	string	No	—	The field name.
— Value	string	No	—	The field value.
Body (bodyRaw)	string	No	—	Raw body content to send. (shown when Send Body is true and Body Content Type is raw)
Content Type	string	No	—	The Content-Type header value for the raw body. (shown when Send Body is true and Body Content Type is raw)

Options

Parameter	Type	Required	Default	Description
Options	collection	No	{}	Response handling, transport settings and pagination.
— Response Format	options	No	autodetect	How to parse the response. Autodetect inspects the Content-Type header.
				Options: autodetect, json, text
— Include Response Headers and Status	boolean	No	false	Whether to include response headers and status code in the output.
— Never Error	boolean	No	false	Whether to succeed even when the HTTP status code is not 2xx.
— Output Property Name	string	No	data	The output field name for text responses.
— Follow Redirects	boolean	No	true	Whether to follow HTTP 3xx redirects.
— Max Redirects	number	No	21	Maximum number of redirects to follow.
— Timeout (ms)	number	No	300000	Request timeout in milliseconds. Default is 300000 (5 minutes).
— Batch Size	number	No	0	Number of items to process before pausing. 0 or -1 disables batching.
— Batch Interval (ms)	number	No	1000	Milliseconds to wait between batches.
— Ignore SSL Issues	boolean	No	false	Whether to accept responses from servers with invalid/self-signed SSL certificates.
— Lowercase Headers	boolean	No	true	Whether to lowercase user-provided header names.
— Array Format in Query Parameters	options	No	brackets	How to serialize arrays in query parameters.
				Options: repeat (foo=1&foo=2), brackets (foo[]=1&foo[]=2), indices (foo[0]=1&foo[1]=2)
— Proxy	string	No	—	HTTP proxy URL. Requires HTTP_PROXY/HTTPS_PROXY environment variable support.
— Pagination Mode	options	No	off	Whether and how to paginate through results.
				Options: off, updateAParameterInEachRequest (change a parameter on every request), responseContainsNextURL (follow a URL found in the response)
— Next URL Expression	string	No	—	Expression that resolves to the next page URL from the response. Use $response to access the response. (shown when Pagination Mode is responseContainsNextURL)
— Pagination Parameters	fixedCollection	No	One qs parameter	Parameters to update in each subsequent paginated request. (shown when Pagination Mode is updateAParameterInEachRequest)
— — Type	options	No	qs	Where the parameter is sent.
				Options: qs (query string), headers, body
— — Name	string	No	—	The parameter name, for example page.
— — Value	string	No	—	The value for the next request, usually an expression over $response.
— Pagination Complete When	options	No	responseIsEmpty	When to stop making paginated requests. (shown when Pagination Mode is updateAParameterInEachRequest, responseContainsNextURL)
				Options: responseIsEmpty, receiveSpecificStatusCodes, other (your own expression)
— Status Codes When Complete	string	No	—	Comma-separated HTTP status codes that indicate pagination is complete. (shown when Pagination Complete When is receiveSpecificStatusCodes)
— Complete Expression	string	No	—	Expression that evaluates to true when pagination should stop. (shown when Pagination Complete When is other)
— Limit Pages Fetched	boolean	No	false	Whether to limit the total number of paginated requests. (shown when Pagination Mode is updateAParameterInEachRequest, responseContainsNextURL)
— Max Pages	number	No	100	Maximum number of paginated requests to make. (shown when Limit Pages Fetched is true)
— Interval Between Requests (ms)	number	No	0	Milliseconds to wait between paginated requests. 0 means no delay. (shown when Pagination Mode is updateAParameterInEachRequest, responseContainsNextURL)

All Requests

Parameter	Type	Required	Default	Description
Max Concurrency	number	No	10	Maximum number of items to process concurrently.

Output Data

The response replaces the item JSON — nothing from the input item passes through, and no binary data is produced. Read anything you still need before this node, or send it down a parallel branch.

The exact shape depends on Response Format and Include Response Headers and Status:

Response Format	Include Headers and Status	Output item
JSON	off	The parsed response body becomes the item JSON
JSON	on	{ "body": …, "headers": {…}, "statusCode": 200, "statusMessage": "OK" }
Text	off	{ "<Output Property Name>": "…" } — data by default
Text	on	The same field, plus headers, statusCode and statusMessage

With autodetect, a JSON Content-Type is parsed as JSON; anything else is treated as text, though a text body that happens to parse as JSON is upgraded to JSON.

A JSON array response fans out. When the body is a top-level array and Include Response Headers and Status is off, the node emits one output item per array element — a list endpoint feeds a per-record branch with no Split Out node in between:

{
  "id": 1,
  "name": "Ada Lovelace",
  "email": "ada@example.com"
}

Turn Include Response Headers and Status on and you get a single item instead, with the whole array under body:

{
  "body": [
    { "id": 1, "name": "Ada Lovelace" },
    { "id": 2, "name": "Alan Turing" }
  ],
  "headers": { "content-type": "application/json" },
  "statusCode": 200,
  "statusMessage": "OK"
}

Pagination adds items, not fields. Every page produces its own output item (and its own per-element items for array bodies), so a run that fetched five pages of ten records leaves fifty items on the output.

A non-2xx status fails the item and is handled according to the node’s error mode. Turn Never Error on to receive the response anyway — pair it with Include Response Headers and Status so a downstream node can branch on statusCode.

Reference the response downstream by expression, e.g. {{ $json.id }} for a plain JSON body or {{ $json.body.id }} when headers and status are included.

Usage Examples

• GET data from a REST API
• POST JSON data to an endpoint
• Call any external API with Bearer token auth
• Fetch paginated results from an API
• Submit a form via HTTP POST

Example Configuration

A plain GET request:

{
  "type": "http_request",
  "parameters": {
    "method": "GET",
    "url": "https://api.example.com/users"
  }
}

GET with query parameters entered as fields:

{
  "type": "http_request",
  "parameters": {
    "method": "GET",
    "url": "https://api.example.com/search",
    "sendQuery": true,
    "specifyQuery": "keypair",
    "queryParameters": {
      "parameters": [
        { "name": "q", "value": "test" },
        { "name": "limit", "value": "10" }
      ]
    }
  }
}

The same request with the query supplied as JSON:

{
  "type": "http_request",
  "parameters": {
    "method": "GET",
    "url": "https://api.example.com/search",
    "sendQuery": true,
    "specifyQuery": "json",
    "jsonQuery": {
      "q": "test",
      "limit": 10,
      "sort": "name"
    }
  }
}

POST a JSON body built from fields, with a custom header:

{
  "type": "http_request",
  "parameters": {
    "method": "POST",
    "url": "https://api.example.com/users",
    "sendHeaders": true,
    "specifyHeaders": "keypair",
    "headerParameters": {
      "parameters": [
        { "name": "Content-Type", "value": "application/json" }
      ]
    },
    "sendBody": true,
    "contentType": "json",
    "specifyBody": "keypair",
    "bodyParameters": {
      "parameters": [
        { "name": "name", "value": "John Doe" },
        { "name": "email", "value": "john@example.com" }
      ]
    }
  }
}

POST a JSON body written directly:

{
  "type": "http_request",
  "parameters": {
    "method": "POST",
    "url": "https://api.example.com/users",
    "sendBody": true,
    "contentType": "json",
    "specifyBody": "json",
    "jsonBody": {
      "name": "John Doe",
      "email": "john@example.com",
      "age": 30
    }
  }
}

POST a form-urlencoded login:

{
  "type": "http_request",
  "parameters": {
    "method": "POST",
    "url": "https://api.example.com/login",
    "sendBody": true,
    "contentType": "form-urlencoded",
    "specifyBodyUrlEncoded": "keypair",
    "bodyParametersUrlEncoded": {
      "parameters": [
        { "name": "username", "value": "user@example.com" },
        { "name": "password", "value": "secretpassword" }
      ]
    }
  }
}

POST multipart form fields:

{
  "type": "http_request",
  "parameters": {
    "method": "POST",
    "url": "https://api.example.com/upload",
    "sendBody": true,
    "contentType": "multipart-form-data",
    "bodyParametersMultipart": {
      "parameters": [
        { "name": "title", "value": "My Document" },
        { "name": "description", "value": "Document description" }
      ]
    }
  }
}

Send a raw XML body:

{
  "type": "http_request",
  "parameters": {
    "method": "POST",
    "url": "https://api.example.com/webhook",
    "sendBody": true,
    "contentType": "raw",
    "bodyRaw": "<xml><data>raw content</data></xml>",
    "rawContentType": "application/xml"
  }
}

Tighten the transport settings and keep the status code:

{
  "type": "http_request",
  "parameters": {
    "method": "GET",
    "url": "https://api.example.com/data",
    "options": {
      "responseFormat": "json",
      "fullResponse": true,
      "timeout": 30000,
      "followRedirects": true,
      "maxRedirects": 5,
      "neverError": false
    }
  }
}

Page through a list endpoint, ten pages at most:

{
  "type": "http_request",
  "parameters": {
    "method": "GET",
    "url": "https://api.example.com/items",
    "options": {
      "paginationMode": "updateAParameterInEachRequest",
      "paginationParameters": {
        "parameters": [
          { "type": "qs", "name": "page", "value": "1" }
        ]
      },
      "paginationCompleteWhen": "responseIsEmpty",
      "limitPagesFetched": true,
      "maxRequests": 10,
      "requestInterval": 1000
    }
  }
}

Call a protected endpoint with a stored Bearer Token credential:

{
  "type": "http_request",
  "parameters": {
    "method": "GET",
    "url": "https://api.example.com/protected",
    "authentication": "httpBearerToken"
  }
}

Update a record, taking the id from the incoming item:

{
  "type": "http_request",
  "parameters": {
    "method": "PUT",
    "url": "https://api.example.com/resources/{{ $json.id }}",
    "sendBody": true,
    "contentType": "json",
    "specifyBody": "json",
    "jsonBody": {
      "name": "Updated Resource",
      "description": "Updated description"
    }
  }
}

Tolerate an unreliable endpoint and inspect the status yourself:

{
  "type": "http_request",
  "parameters": {
    "method": "GET",
    "url": "https://api.example.com/unstable-endpoint",
    "options": {
      "neverError": true,
      "fullResponse": true,
      "timeout": 60000
    }
  }
}

Error Handling

Mode	Behavior
stop	Halts workflow on first error
continue	Skips failed items, passes successful ones through
errorPort	Routes failed items to Error output port

Tips

Makes HTTP requests to any URL with configurable method, auth, headers, body, pagination, and response format. Use when no dedicated integration exists for a service.

Important Notes

1. Conditional parameters — many parameters only appear once the switch above them is on. Check the gates in the tables before adding a field to a saved configuration.
2. Key-value collections — Query Parameters, Headers, Body Parameters and their siblings each hold their entries under a parameters array of name/value objects.
3. Options is a flat object — its fields sit directly inside it, not wrapped in arrays.
4. Authentication — picking a method in Authentication reveals its fields; storing a credential of the same type overrides them.
5. Content-Type — a JSON body sets the header for you. Override it with a custom header only when the API insists on something unusual.

Rate limiting and reliability

• Batch Size and Batch Interval (ms) pause between groups of items, which is the simplest way to stay under an API’s rate limit when many items arrive at once. Max Concurrency controls how many run in parallel.
• Interval Between Requests (ms) does the same job inside a single paginated run.
• Raise Timeout (ms) for slow endpoints, and lower it for ones you would rather fail fast.

Notes

• Binary file uploads are not supported in multipart bodies; send text fields only.
• Lowercase Headers applies to the header names you supply, not to the ones the server returns.
• Ignore SSL Issues disables certificate verification for the request. Use it only against hosts you control.