# HTTP Request Sender – Bulk GET/POST API Calls to JSON (`chris_elder/http-request-sender`) Actor

Fire many HTTP requests and get status, headers and parsed JSON back. Supports methods, query params, JSON or raw body, and a secret auth header (masked in output). Blocks private IPs. $1 per 1,000 requests; failed requests are free.

- **URL**: https://apify.com/chris_elder/http-request-sender.md
- **Developed by:** [Chris Elder](https://apify.com/chris_elder) (community)
- **Categories:** Developer tools, Integrations, Automation
- **Stats:** 1 total users, 1 monthly users, 94.1% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.60 / 1,000 request sents

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## HTTP Request Sender – Send HTTP Requests & Bulk REST API Calls (GET, POST, PUT, PATCH, DELETE)

**HTTP Request Sender** sends HTTP requests to any REST API, webhook or URL and returns clean, structured results: status code, parsed JSON (or text/base64), response headers, redirect chain and timing. Send **one request** – perfect for **Clay, Make, n8n, Zapier** and **AI agents** that need "call this API" as a step – or **thousands in bulk** with rate limiting, retries and per-request labels.

No code, no server, no plan upgrade needed in your no-code tool: it is the missing "HTTP API" block, at **$1 per 1,000 requests** – 5× cheaper than the most-used HTTP request Actor on the Apify Store, which lists $0.005 per request (checked 13 Oct 2026).

Store page: [apify.com/chris_elder/http-request-sender](https://apify.com/chris_elder/http-request-sender)

✅ Pay per result: **$1 per 1,000 requests** · 🆓 Timeouts, connection errors and blocked requests are never charged · 🔑 Your API key stays encrypted

[▶ How to use it](#how-to-use-it) · [📄 Real example output](#output-example-from-a-real-public-run) · [💲 Pricing](#how-much-does-it-cost) · [🔌 API & integrations](#integrations-api-ai-agents-make-zapier-n8n) · [❓ FAQ](#faq) · [🛟 Support](#support-reliability-and-feature-requests)

### Features

- 🔧 **All methods** – GET, POST, PUT, PATCH, DELETE, HEAD, OPTIONS
- 📦 **JSON bodies** (Content-Type set automatically), raw bodies (form data, XML), **query parameters** (arrays → repeated params)
- 🔐 **Secret auth header** – put your API key in an encrypted input field; it's never logged, shown as `***` in results and **never forwarded to another domain** on redirects
- 📚 **Bulk mode** – a list of requests (URL strings or full objects with their own method, headers, body and `label`) with common headers/params merged in
- 🔁 **Reliable** – retries with exponential back-off on network errors, 429 and 5xx, honours `Retry-After`; POST/PATCH are not retried unless you allow it (no accidental double orders)
- 🐢 **Rate limiting** – parallelism cap plus a per-host delay so you stay within the API's limits
- 🧾 **Smart responses** – JSON parsed into objects, text kept as text, binaries (images, PDFs) returned as base64; size cap with a `bodyTruncated` flag
- ↪️ Redirect chains reported (or turn following off)
- 🚦 Optional **fail the run on errors** – great for automations that must stop when an API call fails
- 🛡️ Requests to private/internal network addresses are refused for safety

### How much does it cost?

**$0.001 per request that gets a response** (any status code) – $1 per 1,000. No start fee. Higher Apify plans get automatic discounts (Silver $0.0008, Gold+ $0.0006).

**Requests that time out, can't connect or are refused for safety are free.**

| Usage | Price |
|---|---|
| 1 request (e.g. one Clay row) | $0.001 |
| 1,000 requests | $1 |
| 50,000 requests | $50 (Gold: $30) |

### How to use it

#### Single request (Clay, Make, n8n, Zapier, agents)

```json
{
  "url": "https://api.example.com/v1/companies",
  "method": "POST",
  "jsonBody": { "domain": "apify.com" },
  "secretHeaderName": "Authorization",
  "secretHeaderValue": "Bearer sk_live_..."
}
```

#### Bulk requests

```json
{
  "url": "",
  "headers": { "Accept": "application/json" },
  "requests": [
    "https://api.github.com/repos/apify/crawlee",
    { "url": "https://httpbin.org/post", "method": "POST", "jsonBody": { "hello": "world" }, "label": "echo" },
    { "url": "https://httpbin.org/get", "queryParams": { "q": "apify" } }
  ],
  "maxConcurrency": 5,
  "delayBetweenRequestsMs": 200
}
```

**Bulk mode tip:** omit `url` (or set it to `""`) and put everything in `requests`. Console "Try for free" still prefills a single httpbin URL so one-click Start works; API callers who send only `requests` are not charged for that sample.

#### Example: 2 requests in → 2 result rows out

| Request | Result row |
|---|---|
| `GET https://httpbin.org/get?q=apify` | `statusCode: 200`, `ok: true`, `body.args.q = "apify"` |
| `POST https://httpbin.org/post` with `{"hello":"world"}`, label `echo` | `statusCode: 200`, `ok: true`, `body.json = {"hello":"world"}`, `label: "echo"` |

#### Output example (from a real public run)

Public run data (no login needed): [dataset JSON](https://api.apify.com/v2/datasets/MJxHHicNQnFcuSV2A/items?format=json\&clean=1) · [dataset CSV](https://api.apify.com/v2/datasets/MJxHHicNQnFcuSV2A/items?format=csv\&clean=1)

Second row (the POST), shortened with `...`:

```json
{
  "index": 1,
  "label": "echo",
  "method": "POST",
  "url": "https://httpbin.org/post",
  "requestHeaders": { "content-type": "application/json" },
  "statusCode": 200,
  "ok": true,
  "finalUrl": "https://httpbin.org/post",
  "redirectChain": [],
  "contentType": "application/json",
  "responseBytes": 630,
  "bodyTruncated": false,
  "body": { "args": {}, "data": "{\"hello\":\"world\"}", "json": { "hello": "world" }, "url": "https://httpbin.org/post", "...": "..." },
  "bodyFormat": "json",
  "durationMs": 211,
  "responseHeaders": { "content-type": "application/json", "...": "..." }
}
```

When you use the secret header, its value is shown as `***` in `requestHeaders`.

Failed requests appear with `statusCode: null`, an `error` message and an `errorCode` (e.g. `TIMEOUT`, `ENOTFOUND`) – and are not charged. A `RUN_SUMMARY` record counts responses, non-2xx answers and failures.

### Using it from Clay

Add an **Apify** enrichment column, choose *HTTP Request Sender*, map the row's values into `url`, `queryParams` or `jsonBody`, and read `body` from the result. Each row costs $0.001.

### Integrations (API, AI agents, Make, Zapier, n8n)

```bash
curl -X POST "https://api.apify.com/v2/acts/chris_elder~http-request-sender/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"url":"https://httpbin.org/post","method":"POST","jsonBody":{"hello":"world"}}'
```

Python (`pip install apify-client`):

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("chris_elder/http-request-sender").call(run_input={
    "url": "",  # only use the bulk list
    "requests": [{"url": "https://httpbin.org/get", "queryParams": {"q": "apify"}}],
})
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(row["statusCode"], row["body"])
```

MCP (AI agents): `https://mcp.apify.com/?tools=chris_elder/http-request-sender`

Make / Zapier / n8n: use the Apify **Run Actor** module with `chris_elder/http-request-sender` and read the dataset rows. Works with Apify schedules and webhooks.

### Good to know

- Call only APIs and endpoints you are allowed to use, and respect their terms and rate limits. This Actor is a neutral HTTP client; it does not bypass authentication, CAPTCHAs or bot protection.
- Maximum response size per request is 8 MB (default 5 MB). For large downloads use a dedicated file downloader.
- The secret header is added to every request in the run – don't mix endpoints of different providers in one run if they need different keys.

### FAQ

**Can I send form data?** Yes – put `a=1&b=2` in *Raw body* and add the header `Content-Type: application/x-www-form-urlencoded`.

**Does it support GraphQL?** Yes – POST `{"query": "...", "variables": {...}}` as the JSON body.

**Is my API key safe?** The field is encrypted by Apify, never written to logs or results, and dropped on cross-domain redirects.

**Can I call a webhook?** Yes – POST your JSON to the webhook URL; the response comes back as a row.

**Something missing?** Open an issue on the Actor page.

### Support, reliability and feature requests

- Requests that time out, can't connect or are refused for safety are free.
- Every release is tested on real public endpoints; the example input works.
- Issues answered within 2 business days via the Actor **Issues** tab.
- Breaking input or price changes are announced in this README first.

Built by Chris Elder with AI-assisted development; every release is reviewed and tested.

### Need the data done for you?

If you'd rather not set up runs yourself, the UK company behind these tools (GPT Shop Ltd) offers a fixed-price done-for-you scrape. Tell us the website and the fields you need, and you get a clean CSV or Google Sheet within 48 hours of the confirmed brief, up to 5,000 rows, for £149 or $179. If we can't get the data, you're refunded in full. [See the done-for-you scraper service](https://sme-free-tools.pages.dev/done-for-you-scraper/?utm_source=apify\&utm_medium=readme\&utm_campaign=http-request-sender)

### More tools by Chris Elder

[Bulk File Downloader](https://apify.com/chris_elder/bulk-file-downloader) · [Dataset Transformer](https://apify.com/chris_elder/dataset-transformer) · [Sitemap URL Extractor](https://apify.com/chris_elder/sitemap-url-extractor) · [Bulk WHOIS Lookup](https://apify.com/chris_elder/bulk-whois-domain-lookup) · [all tools](https://apify.com/chris_elder)

# Actor input Schema

## `url` (type: `string`):

Endpoint to call (single-request mode). Prefills for Try-for-free; leave empty / omit when using the bulk 'Requests' list.

## `method` (type: `string`):

HTTP method (also the default for bulk requests without their own method).

## `headers` (type: `object`):

Headers sent with every request, e.g. {"Accept": "application/json"}. Put API keys in the secret field below instead.

## `queryParams` (type: `object`):

Added to the URL of every request, e.g. {"page": 1}. Arrays become repeated parameters.

## `jsonBody` (type: `object`):

JSON body for POST/PUT/PATCH (Content-Type: application/json is set automatically).

## `body` (type: `string`):

Raw text body (form data, XML, …). Set the matching Content-Type header. Ignored when a JSON body is given.

## `requests` (type: `array`):

List of requests to send. Each item is a URL string or an object {"url", "method", "headers", "queryParams", "jsonBody" or "body", "label"}. Common headers/params above are merged in.

## `secretHeaderName` (type: `string`):

Header that carries your credential, e.g. Authorization or X-API-Key.

## `secretHeaderValue` (type: `string`):

e.g. 'Bearer sk_live\_…'. Stored encrypted, never logged, shown as \*\*\* in the output and never forwarded to another domain on redirects.

## `responseFormat` (type: `string`):

auto = JSON is parsed, text stays text, binary becomes base64.

## `includeResponseHeaders` (type: `boolean`):

Add the response headers to each result.

## `followRedirects` (type: `boolean`):

Follow 3xx redirects (the chain is reported).

## `timeoutSecs` (type: `integer`):

Abort a request after this long.

## `retries` (type: `integer`):

Retries on network errors, 429 and 5xx (Retry-After honoured). POST/PATCH are not retried unless enabled below.

## `retryNonIdempotent` (type: `boolean`):

Only enable if the API is safe to call twice (idempotency key).

## `maxResponseBytes` (type: `integer`):

Bigger bodies are truncated (bodyTruncated=true).

## `failRunOnError` (type: `boolean`):

Mark the run as FAILED if any request errors or returns a non-2xx status (useful in automations).

## `maxConcurrency` (type: `integer`):

Requests in flight at once.

## `delayBetweenRequestsMs` (type: `integer`):

Respect the API's rate limits.

## `maxRequests` (type: `integer`):

Safety cap on the number of requests sent.

## Actor input object example

```json
{
  "url": "https://httpbin.org/anything",
  "method": "GET",
  "headers": {},
  "queryParams": {},
  "requests": [],
  "secretHeaderName": "Authorization",
  "responseFormat": "auto",
  "includeResponseHeaders": true,
  "followRedirects": true,
  "timeoutSecs": 30,
  "retries": 2,
  "retryNonIdempotent": false,
  "maxResponseBytes": 5242880,
  "failRunOnError": false,
  "maxConcurrency": 5,
  "delayBetweenRequestsMs": 200,
  "maxRequests": 10000
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

## `summary` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "url": "https://httpbin.org/anything"
};

// Run the Actor and wait for it to finish
const run = await client.actor("chris_elder/http-request-sender").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "url": "https://httpbin.org/anything" }

# Run the Actor and wait for it to finish
run = client.actor("chris_elder/http-request-sender").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "url": "https://httpbin.org/anything"
}' |
apify call chris_elder/http-request-sender --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,chris_elder/http-request-sender"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/rgOjNxAXRJ8lKUrai/builds/l6daTzcv5AfYZWjea/openapi.json