HTTP Request Runner – Bulk API Calls for n8n, Make & Zapier

Run hundreds or thousands of HTTP / REST API requests in one go: GET, POST, PUT, PATCH, DELETE, HEAD or OPTIONS, with your own headers, query parameters and JSON or raw bodies. Give it a list of requests, or one URL/body template plus rows from an Apify dataset, a CSV, a Google Sheet or inline JSON, and it sends one request per row.

Built for n8n, Make (Integromat) and Zapier users who hit loop limits, operation costs or timeouts when they call an API for every row. Here the loop runs on Apify with concurrency, a per-host rate limit, retries with backoff on 429/5xx, pagination and a JSONPath-style field picker, and you get one clean dataset row per request.

$0.50 per 1,000 successful requests. Failed, blocked and non-2xx/3xx requests are free.

What you can do with it

• Enrich a spreadsheet or dataset through any API: one call per row (https://api.example.com/companies/{{domain}}), with the result joined back to the row.
• Bulk POST / PATCH / DELETE: create or update records in a CRM, CMS, e-commerce or ticketing system from a CSV.
• Replace an n8n/Make "HTTP Request" loop: send 5,000 calls in one run, then pull one dataset into your workflow, or have each result POSTed to your webhook.
• Paginate through an API: follow next URLs, cursors or GitHub-style Link headers.
• Health-check endpoints and capture status codes, timings and headers.
• Chain Actors: feed the output dataset of another Apify Actor into API calls.

Features

• Methods: GET, POST, PUT, PATCH, DELETE, HEAD, OPTIONS. Custom headers, query parameters, JSON or raw body (form data, XML, GraphQL...).
• Templating with {{field}} placeholders in the URL, headers, query and body. Dot paths work ({{address.city}}, {{tags.0}}). In URLs, values are URL-encoded; use {{{field}}} for a raw value (for example a full URL). In a JSON body, a string that is exactly "{{field}}" keeps the row's native type (number, list, object).
• Template rows from an Apify dataset (picker), a public CSV / Google Sheets link, or inline JSON.
• Concurrency (1-100) and a max requests per second per host limit.
• Retries on timeouts, network errors, 408, 425, 429 and 5xx with exponential backoff; Retry-After is honored.
• Pagination: next-page path or cursor parameter in JSON, or the Link: rel="next" header.
• Pick fields from JSON responses with paths like $.data.id or items[*].name.
• Response size cap (stops reading after N bytes) and body storage options: dataset (parsed JSON or truncated text), key-value store (full body with a link; good for HTML, files and images) or none.
• Webhook forward: POST every result row to an n8n, Make or Zapier webhook.
• SSRF protection: requests to private, loopback, link-local, cloud-metadata (169.254.169.254) and other reserved addresses are blocked, and so are internal hostnames. DNS is resolved and checked before every connection, including redirects.

Input examples

The prefill sends two requests to httpbin.org (a GET and a JSON POST) and finishes in a few seconds.

One API call per row of a dataset or CSV:

{
  "urls": ["https://api.example.com/v1/companies?domain={{domain}}"],
  "headers": { "Authorization": "Bearer YOUR_API_KEY" },
  "csvUrl": "https://docs.google.com/spreadsheets/d/YOUR_SHEET_ID/edit#gid=0",
  "pick": { "name": "$.data.name", "employees": "$.data.employee_count" },
  "concurrency": 5,
  "maxRequestsPerSecondPerHost": 5
}

Bulk POST with a JSON body template:

{
  "requests": [{
    "method": "POST",
    "url": "https://api.example.com/v1/contacts",
    "headers": { "Authorization": "Bearer YOUR_API_KEY" },
    "json": { "email": "{{email}}", "name": "{{first}} {{last}}", "tags": "{{tags}}" },
    "label": "contact-{{email}}"
  }],
  "templateRows": [
    { "email": "ann@example.com", "first": "Ann", "last": "Lee", "tags": ["lead"] },
    { "email": "bo@example.com", "first": "Bo", "last": "Diaz", "tags": ["customer", "vip"] }
  ]
}

Cursor pagination:

{
  "urls": ["https://api.example.com/v1/orders?limit=100"],
  "maxPagesPerRequest": 50,
  "paginationNextPath": "$.meta.next_cursor",
  "paginationCursorParam": "cursor"
}

GitHub-style Link header pagination, bodies saved as files:

{
  "urls": ["https://api.github.com/repos/apify/crawlee/issues?per_page=100&state=all"],
  "followLinkHeader": true,
  "maxPagesPerRequest": 10,
  "saveBodyTo": "kv",
  "pick": { "numbers": "$[*].number" }
}

Output

One dataset row per request (and per page). The Requests view shows status, timing and picked fields, and the Responses view shows bodies.

{
  "index": 1,
  "label": "post-example",
  "method": "POST",
  "url": "https://httpbin.org/post",
  "requestedAt": "2026-10-22T13:12:40+00:00",
  "durationMs": 547,
  "attempts": 1,
  "finalUrl": "https://httpbin.org/post",
  "statusCode": 200,
  "ok": true,
  "contentType": "application/json",
  "bodyBytes": 482,
  "responseTruncated": false,
  "picked": { "origin": "203.0.113.7", "echo": { "a": 1 } },
  "json": { "json": { "a": 1 }, "url": "https://httpbin.org/post" },
  "responseHeaders": { "content-type": "application/json" },
  "charged": true
}

Other fields: page (with pagination), body + bodyTruncated (non-JSON or large responses), bodyKey + bodyUrl (key-value store mode), input (the template row), error. The run summary is in the key-value store record OUTPUT.

Pricing

Pay per event:

Event	Price
request-sent: a request that got a 2xx or 3xx response (each pagination page counts)	$0.0005 ($0.50 / 1,000)
Actor start	$0.00005
Failed requests (network error, timeout, 4xx, 5xx after retries, SSRF-blocked, invalid)	free

Retries of the same request are not charged again. Set a maximum cost per run and the Actor stops cleanly when it is reached, without sending requests it could not bill.

At the time of writing (October 2026), the most-used similar Actors on the Apify Store list about $0.005 per request.

Use with n8n, Make and Zapier

1. Start the Actor with the Apify node / module / app ("Run Actor"), passing your input JSON.
2. Either wait for the run and fetch the dataset items, or set Forward each result to webhook to your workflow's webhook URL to receive each result as it finishes.

Use with AI agents (Apify MCP)

Through the Apify MCP server, an agent in Claude, ChatGPT or another MCP client can call this Actor to make many API calls at once, for example "call this endpoint for each of these 200 IDs and give me the status codes and the price field".

FAQ

Is my API key safe? Headers are only sent to the URLs you enter. Use the Actor's input as you would any secret config. Apify stores the input with the run, so keep runs private. Response headers are saved to the dataset unless you turn them off.

Which responses are charged? Only those with a 2xx or 3xx status. 4xx/5xx responses still get a row (with status and body), but they are free.

Why was my request blocked? For security, the Actor can't reach private networks, localhost, cloud metadata endpoints or internal hostnames, even through redirects or DNS. Public APIs only.

Can it send files / multipart uploads? Not yet. JSON and raw text bodies are supported.

How big can responses be? Up to 50 MB per response (default cap 5 MB). Large bodies are best saved to the key-value store.

Does it run JavaScript or bypass anti-bot protection? No. It's a plain HTTP client (HTTP/1.1 and HTTP/2) without proxies or browsers. Use it for APIs and endpoints that you're allowed to call.

Rate limits? Set maxRequestsPerSecondPerHost and concurrency to stay inside the API's limits. 429 responses are retried with backoff.

Responsible use

You decide which endpoints you call. Only call APIs and sites that you're allowed to use, and respect their terms and rate limits.