All nodes/Integrations/HTTP & Web

HTTP Request

Performs an HTTP request (GET/POST/PUT/PATCH/DELETE/HEAD) and returns the response status, headers and body. Supports JSON/text/form bodies, a form with files (multipart) and a whole file as the body, bearer/basic/custom-header auth, and templates in the URL, headers and body. The response can be saved as a file in the workspace files and passed on through the File port.

HTTP Request▶

InputService response

FilesFile

Type in the graph: http_request

Exec

An error output can be enabled to handle failures on their own path.

Try it

Minimal working scenario

Entry

HTTP Request▶

Exit▶

Execute + Data
Data

Press “Copy nodes”, open the editor and hit Ctrl+V on the canvas.

Runs as pasted

When to use it

The general-purpose step to any HTTP API that has no node of its own. When a dedicated node exists — Telegram, amoCRM, Bitrix24, calendar, email — use it: authentication, pagination and error shapes are already handled there. To read a web page as text for a model there is Fetch Webpage; for an MCP server there is MCP Tool.

This node is a graph step, not an agent tool: it has no tool_out port, so a model cannot call it. To hand an agent an HTTP call of your own, wrap it in a WF tool.

How it works

The URL, headers, query parameters, body and the auth fields are all rendered as templates, so {{ inputs.input.id }}, {{ variables.token }} and {{ secret.API_KEY }} work in any of them.

Headers, Query Parameters and a form body are a JSON object written as text. Invalid JSON fails the node with a direct message. For GET and HEAD no body is sent, whatever the field contains.

The node has two outputs: Success carries execution onward, and Service response returns the response object — status_code, ok, headers, body, text, url, elapsed_ms. text is always the raw string; body is parsed as JSON only when Parse JSON Response is on and the server sent a Content-Type containing json, otherwise it holds the same string.

Requests to private networks and loopback are blocked, and every redirect hop is validated again. The response is truncated at Max response size (bytes) (1,000,000 by default, 10,000,000 ceiling). The timeout defaults to 30 seconds with a maximum of 120; a plan may lower both.

Files: download and send

Download a file. Set Response to “Save as file”. The body is not decoded; it is saved as is to the workspace files — in the conversation’s folder (sessions/<conversation>/out/) or the run’s (executions/<run>/out/), labelled “Downloaded by a scenario” in the Files tab. A File port appears: wire it to the files port of Message and the model receives the image or PDF as an attachment rather than as a string. The name comes from the File name field, then the Content-Disposition header, then the URL. A file larger than Max file size (20 MB by default, 50 MB ceiling) fails the step — a PDF cut short would open nowhere. A 4xx/5xx response is never saved as the file.

Send a file. Body type “Form with files (multipart)” sends multipart/form-data: the text fields from Body (a JSON object) plus every file on the Files port under the name in File field name. “File” sends one file as the whole body, with its type as Content-Type. Wire a downloaded file, an attachment from a message, or the output of Write XLSX into Files — the writer nodes have the same File port. Do not set your own Content-Type for multipart: the form boundary is added for you.

Saved files count toward the plan’s file quota and are kept until deleted in the Files tab.

Common mistakes

Expecting the response on Success. The value comes out of the Service response port — wire a data edge from it, or read {{ nodes.<id>.output.body }}.
Forgetting how 4xx/5xx is handled. Fail on 4xx/5xx is on by default, so anything outside 2xx goes to the Error output. To inspect the status yourself, turn it off: then Success fires and you decide from ok and status_code.
Reading body when the response was not JSON. A server sending JSON as text/plain leaves you a string to parse.
Mistaking a truncated response for the server’s answer. A large JSON stops parsing once it is cut — raise the byte limit.

Inputs

Port Wire Payload Notes

Port	Wire	Payload	Notes
Input`input`	Execute + Data`execute_data`	—	Execution trigger and optional payload available in templates
Files`files`	Data`data`	`file`	Files to send: form fields for 'Form with files', the whole body for 'File'. Connect a download, a written spreadsheet or an attachment. shown when body_type = "multipart" or "file"

Inputinput

Execute + Dataexecute_data

—

Execution trigger and optional payload available in templates

Filesfiles

Datadata

file

Files to send: form fields for 'Form with files', the whole body for 'File'. Connect a download, a written spreadsheet or an attachment.

shown when body_type = "multipart" or "file"

Outputs

Port	Wire	Payload	Notes
Service response`output`	Data`data`	`object`
File`file`	Data`data`	`file`	shown when response_format = "file"

Configuration

Field	Type	Default	Description
Custom Header Name`auth_header_name`	`string`	`Authorization`	Header name for custom_header auth type shown when «Authorization» = Custom header
Auth Token / Password`auth_token`	`string`	`""`	Bearer token, basic-auth password, or custom-header value secret shown when «Authorization» = Bearer token \| Login and password \| Custom header
Authorization`auth_type`	`string`	`none`	How this request authenticates. The value goes in the field below. Options: `none` — None, `bearer` — Bearer token, `basic` — Login and password, `custom_header` — Custom header
Basic Username`auth_username`	`string`	`""`	Username for basic auth shown when «Authorization» = Login and password
Body`body`	`string`	`""`	Request body. For 'json' — JSON string; for 'form' and 'form with files' — JSON object of key/value pairs sent as text fields. supports templates shown when «Body type» = JSON \| Plain text \| Form \| Form with files (multipart)
Body type`body_type`	`string`	`none`	What the request carries. 'Form' sends application/x-www-form-urlencoded; 'Form with files' sends multipart/form-data with the files from the Files port; 'File' sends one file from the Files port as the whole body. Options: `none` — No body, `json` — JSON, `text` — Plain text, `form` — Form, `multipart` — Form with files (multipart), `file` — File
Fail on 4xx/5xx`fail_on_status`	`boolean`	`true`	Route to Error output on non-2xx responses (otherwise always Success with ok=False)
File field name`file_field`	`string`	`file`	Form field the files from the Files port are sent under. Several files repeat the same field. shown when «Body type» = Form with files (multipart)
File name`file_name`	`string`	`""`	Name to save the downloaded file under. Empty — taken from the Content-Disposition header, then from the URL. supports templates shown when «Response» = Save as file
Follow redirects`follow_redirects`	`boolean`	`true`	Follow a 3xx redirect to the address the server points at.
Headers`headers`	`string`	`""`	JSON object of request headers, e.g. {"X-Foo": "bar"} supports templates
Max file size (bytes)`max_file_bytes`	`integer`	`20000000`	A larger file fails the step instead of being saved cut short. shown when «Response» = Save as file
Max response size (bytes)`max_response_bytes`	`integer`	`1000000`	Truncate response body if it exceeds this size shown when «Response» = Text
Method`method`	`string`	`GET`	HTTP method Options: `GET`, `POST`, `PUT`, `PATCH`, `DELETE`, `HEAD`
Parse JSON Response`parse_json`	`boolean`	`true`	Decode response body as JSON when Content-Type is application/json shown when «Response» = Text
Query Parameters`query_params`	`string`	`""`	JSON object of URL query parameters, e.g. {"page": 1} supports templates
Response`response_format`	`string`	`text`	Text: the body is decoded and available as body/text. File: the body is saved to the workspace files as is and handed on through the File port — use it to download a PDF, an image or a spreadsheet. Options: `text` — Text, `file` — Save as file
Timeout (seconds)`timeout_seconds`	`number`	`30`	Request timeout
URL`url`	`string`	`""`	Target URL (http/https). Templates in {{ }} supported. supports templates
Advanced
Proxy`proxy_url`	`string`	`""`	Send this request through a proxy: http://, https://, socks5:// or socks5h:// (credentials may be inline). Empty = direct. The platform's own route is never applied here — this node calls addresses you choose, so the route is yours to choose too. supports templates

Shared fields

Every node has these three — the platform adds them, not the node author.

expose_error_output — When enabled, show an execution output to connect nodes that run if this step fails.