HTTP Request Sender: Batch API Calls, Pagination & Retries

Send hundreds or thousands of HTTP requests to any REST API or URL in one run and get every response back as a clean dataset row: status code, timing, parsed JSON (or text), errors and, if you want, response headers. GET, POST, PUT, PATCH, DELETE, HEAD and OPTIONS all work, with your own headers, query parameters and JSON, form or raw bodies.

It is built for the jobs where a no-code tool or a spreadsheet needs "just one API call per row": enrich a list through a REST API, push records into a CRM, trigger webhooks, warm a cache, check that endpoints answer, or pull every page of a paginated API into one table.

What you can use it for

• Clay, Make, Zapier and n8n users: call any API without a paid HTTP plan, one run for the whole list instead of one run per call
• Enrichment: a URL template like https://api.example.com/companies/{{domain}} plus a list of rows = one request per row, results in one dataset
• Bulk create / update: POST or PATCH a JSON body per record (placeholders work inside the body too)
• Pull a paginated API: follow page=1,2,3… or a next link and split the returned array into one row per item
• Webhooks and health checks: fire a batch of webhooks, check that a list of endpoints answers 200, measure response times
• Geo tests: route requests through Apify Proxy in a chosen country

Why this one

• $2.50 per 1,000 responses, half the price of the other HTTP-request actors ($5 per 1,000)
• Network errors and timeouts are free: you pay only when a server actually answered
• Retries done right: retries on 408/425/429/5xx and network errors with back-off, and it waits for the server's Retry-After
• Templates: {{placeholders}} from your rows in the URL, headers, query params and body; a placeholder that is the whole value keeps its type (numbers stay numbers in JSON)
• Pagination built in: page-number, offset (set the step) or next-link (next, links.next, paging.next.url …)
• Array splitting: splitItemsPath: "data.items" turns one API response into one dataset row per item — ready for CSV or Excel
• Rate-limit friendly: parallel requests (1–50) plus a global minimum delay between requests
• Binary files: download images or PDFs as base64 when you need the bytes

Input

Field	What it does
Requests	List of URL strings or objects {url, method, headers, queryParams, body, bodyType, label}
URLs (simple mode)	Plain URLs sent with the shared settings
URL template + Template rows	One request per row, {{field}} filled from the row
Shared method / headers / query params / body	Defaults for every request (a request's own values win)
Body type	JSON (default), form (x-www-form-urlencoded) or raw text
Response format	Auto, JSON, text or base64
Split JSON array into rows	Dot path to an array in the response (. = top-level array)
Page parameter, start page, page step	Page-number or offset pagination
Next-page URL path	Follow a next link in the JSON response
Max pages per request	How far to paginate
Parallel requests, delay, timeout, retries, retry codes	Speed and politeness
Max requests	Hard cap per run
Proxy	Optional Apify Proxy with country

Example input, three ways at once:

{
  "requests": [
    {"url": "https://jsonplaceholder.typicode.com/posts", "method": "POST", "body": {"title": "Hello", "userId": 1}, "label": "create post"}
  ],
  "urlTemplate": "https://jsonplaceholder.typicode.com/users/{{id}}",
  "templateRows": [{"id": 1, "label": "first"}, {"id": 2, "label": "second"}],
  "headers": {"Accept": "application/json"},
  "maxConcurrency": 5
}

Pagination example (every page of a list, one row per item):

{
  "urls": ["https://pokeapi.co/api/v2/pokemon?limit=100"],
  "nextUrlPath": "next",
  "splitItemsPath": "results",
  "maxPagesPerRequest": 20
}

Output

One row per response (or one row per array item when you split):

{
  "requestIndex": 0,
  "label": "create post",
  "method": "POST",
  "url": "https://jsonplaceholder.typicode.com/posts",
  "ok": true,
  "status": 201,
  "statusText": "Created",
  "contentType": "application/json",
  "contentLength": 47,
  "attempts": 1,
  "elapsedMs": 252,
  "json": {"title": "Hello", "userId": 1, "id": 101}
}

Other fields when they apply: body (text responses), bodyTruncated, bodyBase64, finalUrl (after redirects), responseHeaders, page, pageIndex, itemIndex + item (split mode), error (for example HTTP 404 or the network error).

How much does it cost?

Pay per event: $0.0025 per HTTP response (any status code) plus $0.001 per run start. Requests that fail before a server answers (DNS errors, timeouts, refused connections) are free. Higher Apify plans get tier discounts (Bronze −5%, Silver −10%, Gold and up −15%).

Worked examples (Free tier):

• 200 enrichment calls from a URL template: 200 × $0.0025 = $0.50 + $0.001
• A paginated API, 30 pages of 100 items split into 3,000 rows: 30 responses × $0.0025 = $0.075 — you pay per page, not per item
• 5,000 webhook POSTs: $12.50; at 256 MB the platform compute for such a run is a few cents

Set a maximum cost per run in Apify and the actor stops cleanly when it is reached.

FAQ

Is it legal? The actor sends the requests you define, to the APIs and URLs you choose, like curl or Postman would. You are responsible for having the right to call those endpoints and for respecting their terms and rate limits (use the delay setting).

Where do I put my API key? In the shared headers (for example Authorization: Bearer …) or as a query param. Inputs are stored in your own Apify account; keep runs private if you share the account.

Do placeholders work in the body? Yes, in the URL, headers, query params and body, with dot paths like {{user.id}}.

How are non-2xx responses handled? They are returned with ok: false and error: "HTTP 4xx". 429 and 5xx are retried first. Turn on "Only output successful responses" to keep them out of the dataset.

What is the order of the rows? Rows arrive as responses complete; sort by requestIndex (and pageIndex / itemIndex) to restore input order.

Can it call localhost or cloud metadata addresses? Link-local and metadata addresses are refused.

Can I send files? Bodies are JSON, form or raw text. Multipart file uploads are not supported yet.

Tips

• Start with maxRequests: 10 to check headers and bodies, then raise it.
• For APIs with strict rate limits, set parallel requests to 1 and a delay (for example 1,000 ms).
• For offset pagination, set the page parameter to offset, start page 0 and page step to your page size.

Integrations

Run it from the Apify API, a schedule, Make, Zapier, n8n or Clay, and read the dataset as JSON, CSV or Excel. Chain it after another actor with a webhook to call an API for every row that actor found.

Changelog

• 0.1 (Oct 2026): first release — batch requests, templates, retries with Retry-After, page/offset/next-link pagination, array splitting, base64 bodies, proxy by country.