Universal Request Runner — Send Any HTTP Request

Send any HTTP request to any URL from the cloud — with automatic retries, residential proxies, sticky sessions and anti-bot fingerprinting built in.

Universal Request Runner is a lightweight HTTP client Actor for the Apify platform. Send GET, POST, PUT, PATCH, DELETE, HEAD, or OPTIONS requests to any API or endpoint — with custom headers, a custom body, automatic JSON handling and Apify's proxy network — directly from the cloud. No code, no server, no Postman required. The response (status code, headers, and auto-parsed JSON body) is saved to a dataset you can download as JSON, CSV, Excel, or HTML.

It is built to never fail a run: if a target is down or slow, the Actor retries with exponential backoff and still saves a diagnostic record — so your scheduled workflows, API monitors and Make/Zapier/n8n automations keep working even when the target does not.

---

What can you use this HTTP request Actor for?

• Call any REST API — send an API key in the headers and JSON in the body, get the parsed response back in seconds.
• Send webhooks & form submissions from the cloud — POST data to any endpoint on a schedule, from Make, Zapier, n8n, or the Apify API.
• Scheduled API monitoring — check whether an API is up every hour and get the status code logged to a dataset automatically.
• Bypass IP blocks & rate limits — route requests through Apify's residential proxy network.
• Keep the same IP across runs — attach a sessionId for a sticky proxy session (start a job from one IP, check its status later from the same IP).
• Bypass Cloudflare & anti-bot protection — opt into browser TLS fingerprinting (curl_cffi) that mimics a real Chrome/Safari/Edge client.
• Automate API calls without a server — no infrastructure to maintain; runs trigger via schedule, API, or integrations.

---

Why use this Actor instead of curl, Postman, or a script?

Need	curl / Postman	Universal Request Runner
Run from the cloud on a schedule	❌	✅ Built-in scheduling
Automatic retries with backoff	❌ Manual scripting	✅ Built-in, respects Retry-After
Use residential proxy IPs	❌ Manual setup	✅ One toggle
Consistent identity via sticky sessions	❌ Hard to manage	✅ Just set a sessionId
Auto-save every response to a database	Manual	✅ Dataset + key-value store, exportable
Survives target outages (never-fail design)	❌ Script exits with error	✅ Run still succeeds, failure is recorded
Share with non-developers	❌	✅ Just a form, no code

---

How to send an HTTP request from the cloud

1. Open the Actor on Apify Store and click Try for free.
2. Fill in the input form — only Target URL and HTTP Method are required.
3. (Optional) Add Custom Headers (e.g. {"Authorization": "Bearer xyz"}) and a Request Body.
4. (Optional) Enable Proxy Configuration → Apify Proxy to route through residential IPs.
5. (Optional) Add a Session ID to keep requests on the same proxy identity.
6. Click Start. The response appears under Output and Dataset within seconds.

You can also run it on a schedule, or trigger it via the Apify API, Make, Zapier, n8n, or any webhook.

---

Input parameters

Field	Type	Required	Description
url	string	✅	Target URL, e.g. https://api.example.com/v1/users. Must start with http:// or https://.
method	enum	✅	GET, POST (default), PUT, PATCH, DELETE, HEAD, OPTIONS.
headers	object	❌	Custom headers as JSON, e.g. {"Authorization": "Bearer xyz"}.
body	string	❌	Request body — JSON or plain text. JSON is detected automatically and sent with Content-Type: application/json. Ignored for GET/HEAD/DELETE/OPTIONS.
followRedirects	boolean	❌	Follow 3xx redirects automatically and return the final page. Default false — you get the raw redirect response so you can see where it points.
maxRetries	integer	❌	Automatic retries on network errors, timeouts, 429 and 5xx. Default 2 (3 attempts total), waits grow 1s → 2s → 4s… and honor the server's Retry-After. Retries cost nothing extra.
timeoutSecs	integer	❌	Per-attempt timeout in seconds. Default 30, max 600.
sessionId	string	❌	Sticky proxy session — runs sharing a sessionId use the same exit IP. Requires a proxy.
proxyConfiguration	object	❌	Apify Proxy editor. Enable useApifyProxy for residential IPs.
useCurlCffi	boolean	❌	Send via curl_cffi with a real browser TLS/HTTP2 fingerprint — for Cloudflare/Akamai-protected targets. Default false.
impersonate	string	❌	Browser fingerprint to mimic when useCurlCffi is on: chrome (default), chrome131, safari, edge, … Falls back to chrome automatically if unsupported.

Sample input:

{
    "url": "https://httpbin.org/post",
    "method": "POST",
    "headers": {
        "Authorization": "Bearer my_token_123",
        "X-Custom-Header": "hello"
    },
    "body": "{\"name\": \"Alice\", \"age\": 30}",
    "maxRetries": 2,
    "sessionId": "mysession1",
    "proxyConfiguration": { "useApifyProxy": true }
}

---

Output

Every run writes exactly one record to the default dataset, and stores the latest result under the key OUTPUT in the key-value store.

{
    "success": true,
    "url": "https://httpbin.org/post",
    "requestedUrl": "https://httpbin.org/post",
    "method": "POST",
    "statusCode": 200,
    "statusMessage": "OK",
    "responseHeaders": { "content-type": "application/json" },
    "responseBody": {
        "json": { "name": "Alice", "age": 30 },
        "origin": "203.0.113.7",
        "url": "https://httpbin.org/post"
    },
    "attempts": 1,
    "durationMs": 812,
    "timestamp": "2026-10-15T12:00:00+00:00"
}

JSON responses are automatically parsed into an object. HTML or plain-text responses are kept as raw strings — nothing is lost.

Never-fail design: when a request cannot be delivered (timeout, DNS failure, blocked connection), the run still succeeds and the record contains "success": false plus error and stack fields explaining what happened — visible in the Failed Requests dataset view. Your scheduled workflows downstream never break because a target was down. Download results as JSON, HTML, CSV, or Excel from the Console.

---

How much does it cost to send an HTTP request?

This Actor uses Apify's Pay-Per-Event (PPE) model — you pay a fixed price per request, no subscription, no rental.

Event	When it's charged	Price
request-sent	When a response arrives (any status code, including 4xx/5xx)	$0.01 per request
apify-actor-start	Once per Actor run (platform default)	~$0.00005

Examples: 100 requests ≈ $1, 1,000 requests ≈ $10. Automatic retries are included in the price — a request that needs 3 attempts is still billed once.

Fair-billing policy: you are charged only when your request actually reached the target and a response was recorded. Pure network failures (target down, DNS error, connection refused) and invalid inputs are recorded for diagnosis but never charged.

Apify's compute cost is billed separately by the platform, but a single request completes in 1–3 seconds, so it is negligible. See exact pricing on the Actor's Store page before running.

---

Advanced: bypass Cloudflare and anti-bot protection

Some sites (protected by Cloudflare, Akamai, Datadome, or PerimeterX) detect and block non-browser HTTP clients by their TLS fingerprint. Enable Use curl_cffi in the input to send the request with a real browser's TLS/HTTP2 fingerprint:

• The Actor mimics Chrome (or Safari/Edge — your choice in impersonate).
• If you supply your own User-Agent / Sec-CH-UA headers, their version numbers are automatically aligned with the impersonated browser so anti-bot cross-checks don't flag a mismatch.
• For best results, combine with Apify Proxy (residential IPs).

Leave it OFF for normal APIs — plain httpx is faster for those.

---

Tips for reliable API automation

• JSON body: just paste JSON — Content-Type: application/json is set automatically. Override by setting the header yourself if needed.
• GET / HEAD / DELETE: the body field is ignored for these methods.
• Redirects: not followed by default, so you see the raw 3xx response. Turn on followRedirects when you need the final page.
• Rate-limited APIs: keep the default maxRetries: 2 — 429 responses are retried automatically, honoring the server's Retry-After.
• Sticky identity: reuse a sessionId (with proxy enabled) where the target expects the same IP across calls.
• One request per run, by design — keeps the Actor simple and composable. Chain runs via the Apify API, scheduling, or integrations like Make/n8n.

---

Run locally

# 1. Install the Apify CLI
npm install -g apify-cli

# 2. Authenticate
apify login

# 3. Install dependencies
python -m venv .venv
source .venv/bin/activate   # Windows: .venv\Scripts\activate
pip install -r requirements.txt

# 4. Run with a test input
apify run --input-file ../test-input.json

Results are written to the local storage/ directory. Local storage isn't pushed to the Apify Console — deploy to see results there. To test with a proxy locally, include proxyConfiguration with useApifyProxy: true in your input (uses your account's proxy quota).

---

FAQ

Does it work without an Apify account? Locally, yes — requests are sent directly. On the platform, you need an Apify account; proxy usage needs proxy quota.

Can I send multiple requests in one run? No, by design. One request per run keeps it simple and composable — chain runs together for multi-step flows.

What happens if the target API is down? The Actor retries (default 2 retries with backoff), then records "success": false with the error details and finishes successfully. The run is not marked as failed and you're not charged.

Why is a 404/500 response a "success"? success: true means your request reached the target and a response came back — even if the server reported an error. That's exactly what you wanted to know when testing an API.

Is my API token or Authorization header logged? No. The Actor uses Apify's logger, which censors sensitive data. Your headers are sent only to the target URL.

How is this different from the free Apify HTTP client? This Actor adds automatic retries with backoff, sticky proxy sessions, browser TLS fingerprinting for anti-bot bypass, full input validation with a never-fail guarantee, and richer per-request metadata (attempts, duration, timestamps) in the dataset.

---

Support

Found a bug or want a feature? Open an issue on the Actor's page in the Apify Console (Actors → My actors → universal-request-runner → Issues), or contact the developer for custom solutions.

Disclaimer: This Actor is a generic HTTP client. You are responsible for complying with the target service's Terms of Service and applicable law.