HTTP Request

HTTP Request

Send HTTP requests (GET, POST, PUT, PATCH, DELETE) to any API endpoint from the Apify platform. Customize headers, query parameters, and request body. Forward responses to a callback URL for Clay and no-code integrations.

Send any HTTP request from the cloud — GET, POST, PUT, PATCH, DELETE — with custom headers, query params, and JSON body. Forward responses to webhook URLs for Clay, Make, or Zapier.

ParseBird Infra Suite   •  Utility tools for data pipelines
🔗  HTTP Request ➤ You are here	📚  Data Deduplicator Merge & deduplicate datasets by any field	🗡  Data Cleaner Clean nulls, normalize case, format phones & emails

Copy to your AI assistant

Copy this block into ChatGPT, Claude, Cursor, or any LLM to start using this actor.

parsebird/http-request-actor on Apify. Call: ApifyClient("TOKEN").actor("parsebird/http-request-actor").call(run_input={...}), then client.dataset(run["defaultDatasetId"]).list_items().items for results. Key inputs: method (string, "GET"/"POST"/"PUT"/"PATCH"/"DELETE", default "GET"), url (string, required), headers (object, optional), params (object, optional), data (object, optional — request body for POST/PUT/PATCH), callbackUrl (string, optional — forwards response as POST), lookupKey (string, optional — identifier for Clay row matching). Full actor spec: fetch build via GET https://api.apify.com/v2/acts/parsebird~http-request-actor (Bearer TOKEN). Get token: https://console.apify.com/account/integrations

What does HTTP Request do?

This Actor sends an HTTP request to any API endpoint and returns the full response — status code, headers, and parsed body — as structured data in an Apify dataset. It supports all common HTTP methods: GET, POST, PUT, PATCH, and DELETE.

Key features:

• Any HTTP method — GET for fetching data, POST for creating resources, PUT/PATCH for updates, DELETE for removal
• Custom headers — pass Authorization tokens, API keys, Content-Type, or any custom header
• Query parameters — append URL query parameters without manually building the URL string
• JSON request body — send structured data with POST, PUT, and PATCH requests
• Callback URL — forward the full response to a webhook endpoint (Clay, Make, Zapier, n8n)
• Lookup key — tag each response with an identifier for row-level matching in Clay tables

Why use this instead of Clay's built-in HTTP?

Clay's Explorer plan limits you to 25 credits/month for HTTP requests. At scale this means:

Scenario	Clay Explorer	This Actor
1,000 API calls/month	$200+/mo plan required	$5.00 total
10,000 API calls/month	$800+/mo plan required	$50.00 total
50,000 API calls/month	Custom enterprise pricing	$250.00 total

By offloading HTTP requests to this Actor, you can stay on Clay's cheaper plan and save hundreds of dollars per month.

Input parameters

Parameter	Type	Required	Default	Description
method	string	No	GET	HTTP method: GET, POST, PUT, PATCH, or DELETE
url	string	Yes	—	Full URL to send the request to
headers	object	No	{}	Custom request headers (e.g. {"Authorization": "Bearer ..."})
params	object	No	{}	URL query parameters (e.g. {"page": "1", "limit": "50"})
data	object	No	—	JSON request body for POST, PUT, and PATCH
callbackUrl	string	No	—	Webhook URL to forward the full response as a POST
lookupKey	string	No	—	Identifier to include in the response for row matching

Output example

{
    "data": {
        "id": 12345,
        "name": "John Doe",
        "email": "john@example.com"
    },
    "status": 200,
    "statusText": "OK",
    "headers": {
        "content-type": "application/json",
        "x-request-id": "abc-123"
    },
    "lookupKey": "row-42"
}

How to use with Clay

1. In your Clay table, add a new column → Run Actor
2. Select parsebird/http-request-actor
3. Map your API URL column to the url input
4. Set method to POST and map your request body to data
5. Optionally set lookupKey to your row ID column for matching
6. Run the enrichment — responses appear as structured JSON in your table

How to use via API

Python

from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("parsebird/http-request-actor").call(run_input={
    "method": "GET",
    "url": "https://api.example.com/users",
    "headers": {"Authorization": "Bearer YOUR_TOKEN"},
    "params": {"limit": "100"},
})

results = client.dataset(run["defaultDatasetId"]).list_items().items
print(results[0]["data"])

cURL

curl -X POST "https://api.apify.com/v2/acts/parsebird~http-request-actor/runs?token=YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "method": "POST",
    "url": "https://api.example.com/leads",
    "headers": {"Authorization": "Bearer API_KEY"},
    "data": {"name": "Jane", "email": "jane@co.com"}
  }'

How it works

1. Reads input configuration (method, URL, headers, params, body)
2. Sends the HTTP request using httpx with a 120-second timeout
3. Parses the response — JSON bodies are parsed automatically, text bodies are stored as strings
4. Saves the full result (data, status, statusText, headers, lookupKey) to the dataset
5. If a callback URL is provided, forwards the result as a POST request

Pricing

This Actor uses a pay-per-event pricing model.

Event	Price per event	Price per 1,000
http-request-sent	$0.005	$5.00

Each HTTP request sent counts as one billable event. Platform compute costs are additional.

Integrations

This Actor works with any system that can trigger Apify runs: Clay, Make (Integromat), Zapier, n8n, custom scripts, and the Apify API.