Webhook Lead Pusher

Webhook Lead Pusher delivers enriched lead data to any HTTP endpoint — Zapier, Make, N8N, HubSpot, Salesforce, or your own custom API — with zero configuration required. It is built for teams that generate leads on Apify and need to get that data into downstream systems automatically, without writing glue code or managing HTTP clients.

Feed in any array of lead objects and point the actor at your webhook URL. It handles authentication, request batching, retries, and delivery confirmation, then returns a structured audit trail of every request made. Combine it with the Website Contact Scraper, Google Maps Email Extractor, or any other actor in a chained run to create a fully automated lead generation pipeline.

What data can you push?

Data Point	Source	Example
📧 Email address	Lead input field	[email protected]
👤 First / last name	Lead input field	Sarah Chen
🏢 Company name	Lead input field	Pinnacle Industries
💼 Job title	Lead input field	VP of Engineering
📞 Phone number	Lead input field	+1-415-555-0182
🔗 LinkedIn URL	Lead input field	https://linkedin.com/in/sarahchen
🌐 Website	Lead input field	https://pinnacle-industries.com
🏷️ Custom fields	Any key/value pair	{"leadScore": 87, "source": "google-maps"}
✅ Delivery status	Actor output	delivered / retried_delivered / failed
⏱️ Request duration	Actor output	342 ms
🔢 HTTP status code	Endpoint response	200
📋 Response body	Endpoint response	{"id": "lead_abc123", "status": "created"}

Why use Webhook Lead Pusher?

Every lead generation workflow ends with the same problem: you have data in one place and need it somewhere else. Copying JSON between tabs is manual and error-prone. Writing a custom HTTP client for every destination wastes engineering time. SaaS tools like Zapier charge $49-299/month for the same connectivity, on top of per-task fees once you exceed plan limits.

This actor automates the delivery step entirely. Run it at the end of any Apify pipeline and your leads land in your CRM, spreadsheet, or automation platform within seconds of being scraped.

• Scheduling — run daily, weekly, or after every upstream scrape to keep your CRM updated automatically
• API access — trigger delivery runs from Python, JavaScript, or any HTTP client as part of an existing pipeline
• Audit trail — every HTTP request and response is logged to the dataset, so you always know what was delivered and when
• Monitoring — get Slack or email alerts when delivery runs fail or endpoints return unexpected status codes
• Integrations — native compatibility with Zapier, Make, N8N, HubSpot native webhooks, Salesforce Connected Apps, or any REST endpoint

Features

• Three delivery modes — individual (one request per lead), batch (all leads in one request), or chunks (configurable group size up to 1,000 leads per request)
• Multi-endpoint fan-out — supply a primary webhookUrl plus any number of additional webhookUrls to deliver the same leads to multiple systems in a single run
• Bearer token authentication — set authToken once and it is injected as Authorization: Bearer {token} on every request; token is masked in logs
• Custom HTTP headers — add any header key/value pairs (API keys, correlation IDs, source tags) alongside the auto-set Content-Type: application/json
• Handlebars-style payload templates — use {{fieldName}} to inject specific lead fields or {{lead}} for the full JSON object, enabling arbitrary payload shapes required by strict APIs
• Automatic retry logic — 5xx server errors and network timeouts are retried once after a 2-second delay; 4xx client errors (400, 401, 403, 404, 422) are not retried, preventing duplicate charges
• Configurable request delay — set milliseconds between requests in individual and chunks modes to stay within destination endpoint rate limits (default 200ms)
• 30-second request timeout — every HTTP request is hard-aborted after 30 seconds to prevent stalled runs
• Payload envelope control — wrap leads in {"leads": [...]} or send raw objects/arrays depending on what your endpoint expects
• Lead cap enforcement — maxLeads parameter caps processing at up to 10,000 leads per run with hard validation
• Spending limit awareness — in pay-per-event mode the actor stops immediately when your budget ceiling is reached, with no partial charges on undelivered leads
• Structured delivery audit — every request produces a DeliveryResult record (status, HTTP code, response body up to 500 chars, duration, timestamp) saved to the Apify dataset
• Summary record — a final summary row is written with total delivered, total failed, endpoint count, batch mode, and completion timestamp

Use cases for webhook lead pusher

Automated CRM population after scraping

Sales operations teams scrape prospect lists with actors like Website Contact Scraper or Google Maps Lead Enricher and need those records in HubSpot or Salesforce immediately. Run this actor as the final step in a chained pipeline — every new lead appears in the CRM within seconds, fully enriched, with no manual import or CSV upload.

Zapier and Make automation triggers

Marketing teams build automations in Zapier or Make that trigger off inbound webhook calls: send welcome emails, add to nurture sequences, notify Slack channels, update Google Sheets. This actor is the missing upstream piece that feeds those automations with fresh lead data from Apify scraping runs, on a schedule or on-demand.

N8N self-hosted workflow integration

Engineering teams running self-hosted N8N instances can use this actor to push structured lead JSON to any N8N webhook trigger node. Combined with N8N's internal node library, this creates a fully self-hosted enrichment and routing pipeline with no third-party SaaS dependency.

Multi-system fan-out for agency clients

Agencies running lead generation for multiple clients need to deliver the same batch of leads to different endpoints simultaneously: one for the CRM, one for the email platform, one for the client's own API. The webhookUrls fan-out feature sends identical payloads to all endpoints in a single run, with per-endpoint delivery tracking in the output.

Lead pipeline testing and validation

Before deploying a new scraping pipeline to production, QA engineers send test batches to staging webhook endpoints to validate payload structure, field completeness, and endpoint behaviour. The structured DeliveryResult output with HTTP status codes and response bodies makes it trivial to assert that the endpoint received and accepted the data correctly.

Real-time lead routing for outbound SDR teams

SDR managers set up webhook endpoints that fan leads into different sales rep queues based on territory or vertical. This actor runs on a schedule every morning, pushing the previous day's scraped leads into the routing endpoint. Combined with B2B Lead Qualifier for pre-scoring, only high-quality leads ever reach the endpoint.

How to push leads to a webhook

1. Enter your webhook URL — paste the endpoint URL into the Webhook URL field. This can be a Zapier catch hook URL (https://hooks.zapier.com/hooks/catch/...), a Make webhook URL, an N8N trigger URL, or any custom HTTPS endpoint.
2. Paste your lead array — in the Leads field, paste a JSON array of lead objects. Each object can have any fields. If you are running this after another Apify actor, use the dataset-to-input chaining feature to pass leads automatically.
3. Choose a delivery mode — Individual is the default and works with most automation platforms. Use Batch when your endpoint accepts arrays. Use Chunks with a chunk size of 10-100 when pushing to APIs with per-request lead limits.
4. Click Start and download results — the run typically completes in under a minute for 100 leads. Download the delivery audit from the Dataset tab in JSON or CSV format to confirm all leads were accepted.

Input parameters

Parameter	Type	Required	Default	Description
webhookUrl	string	Yes	—	Primary HTTP(S) endpoint to deliver leads to
leads	array	Yes	—	Array of lead objects to push (any fields)
webhookUrls	array	No	—	Additional endpoints for fan-out delivery to multiple systems
method	string	No	POST	HTTP method: POST, PUT, or PATCH
authToken	string	No	—	Bearer token; sent as Authorization: Bearer {token}
headers	object	No	—	Additional HTTP headers as key/value pairs
batchMode	string	No	individual	Grouping mode: individual, batch, or chunks
chunkSize	integer	No	50	Leads per request in chunks mode (1-1,000)
wrapInPayload	boolean	No	true	Wrap leads in {"leads": [...]} envelope
payloadTemplate	string	No	—	Handlebars-style template for custom payload shapes
retryOnFailure	boolean	No	true	Retry once after 2s on 5xx or network errors
maxLeads	integer	No	1000	Cap on leads processed per run (1-10,000)
delayBetweenRequests	integer	No	200	Milliseconds between requests in individual/chunks modes

Input examples

Zapier webhook — individual delivery (most common):

{
    "webhookUrl": "https://hooks.zapier.com/hooks/catch/1234567/abcdefg/",
    "leads": [
        {
            "firstName": "Sarah",
            "lastName": "Chen",
            "email": "[email protected]",
            "company": "Pinnacle Industries",
            "title": "VP of Engineering",
            "phone": "+1-415-555-0182"
        },
        {
            "firstName": "Marcus",
            "lastName": "Webb",
            "email": "[email protected]",
            "company": "Delta Logistics",
            "title": "Head of Operations",
            "phone": "+1-312-555-0294"
        }
    ],
    "batchMode": "individual",
    "retryOnFailure": true
}

Custom API — chunked delivery with Bearer auth and custom payload shape:

{
    "webhookUrl": "https://api.mycrm.com/v2/contacts/bulk",
    "webhookUrls": [
        "https://hooks.zapier.com/hooks/catch/1234567/backup/"
    ],
    "leads": [
        {
            "firstName": "Priya",
            "lastName": "Nair",
            "email": "[email protected]",
            "company": "Vortex Technologies",
            "title": "CTO",
            "leadScore": 91
        }
    ],
    "method": "POST",
    "authToken": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...",
    "batchMode": "chunks",
    "chunkSize": 25,
    "wrapInPayload": false,
    "payloadTemplate": "{\"contact_name\": \"{{firstName}} {{lastName}}\", \"contact_email\": \"{{email}}\", \"account\": \"{{company}}\", \"raw\": {{lead}}}",
    "retryOnFailure": true,
    "delayBetweenRequests": 500
}

Minimal single-lead test:

{
    "webhookUrl": "https://httpbin.org/post",
    "leads": [
        {
            "email": "[email protected]",
            "company": "Test Corp"
        }
    ],
    "batchMode": "individual",
    "wrapInPayload": true,
    "maxLeads": 1
}

Input tips

• Use httpbin.org/post for testing — set webhookUrl to https://httpbin.org/post to verify your payload shape before pointing at a live endpoint; it echoes the full request back as JSON.
• Match batchMode to your platform — Zapier and Make work best with individual; bulk import APIs expect batch or chunks; check your endpoint's documentation for array support.
• Set delayBetweenRequests for rate-limited endpoints — Zapier free plans process ~1 task/second; set a delay of 1000ms or more to avoid 429 errors when pushing large batches.
• Use payloadTemplate for strict APIs — some CRMs require specific field names (contact_email vs email); define a template once and every lead is reshaped automatically without preprocessing.
• Fan-out to backups — add a secondary logging endpoint in webhookUrls alongside your primary CRM to keep an independent record of every lead that was delivered.

Output example

{
    "webhookUrl": "https://hooks.zapier.com/hooks/catch/1234567/abcdefg/",
    "status": "delivered",
    "httpStatus": 200,
    "responseBody": "{\"id\": \"01HXYZ9ABC123\", \"status\": \"success\", \"attempt\": 1}",
    "leadsInRequest": 1,
    "error": null,
    "deliveredAt": "2026-03-23T14:22:07.431Z",
    "requestDuration": 287
}

The final record in every dataset is a summary row:

{
    "type": "summary",
    "totalLeadsInput": 50,
    "totalDelivered": 49,
    "totalFailed": 1,
    "endpointsTargeted": 2,
    "batchMode": "individual",
    "method": "POST",
    "completedAt": "2026-03-23T14:22:51.003Z"
}

Output fields

Field	Type	Description
webhookUrl	string	The endpoint URL this request was sent to
status	string	delivered, failed, retried_delivered, or retried_failed
httpStatus	integer or null	HTTP status code returned by the endpoint
responseBody	string or null	First 500 characters of the endpoint's response body
leadsInRequest	integer	Number of leads included in this specific HTTP request
error	string or null	Error message if delivery failed; null on success
deliveredAt	string	ISO 8601 timestamp when the request completed
requestDuration	integer	Total round-trip time in milliseconds
type	string	"summary" on the final summary record only
totalLeadsInput	integer	Summary: total leads received as input
totalDelivered	integer	Summary: leads successfully delivered (including retried)
totalFailed	integer	Summary: leads that failed on all attempts
endpointsTargeted	integer	Summary: number of endpoints contacted
completedAt	string	Summary: ISO 8601 run completion timestamp

How much does it cost to push leads to a webhook?

Webhook Lead Pusher uses pay-per-event pricing — you pay $0.01 per lead successfully delivered. Platform compute costs are included. Failed deliveries are not charged.

Scenario	Leads delivered	Cost per lead	Total cost
Quick test	1	$0.01	$0.01
Small batch	25	$0.01	$0.25
Medium batch	100	$0.01	$1.00
Large batch	500	$0.01	$5.00
Enterprise	5,000	$0.01	$50.00

You can set a maximum spending limit per run to control costs. The actor stops when your budget is reached, so you are never surprised by an unexpectedly large bill.

Compare this to Zapier at $49-299/month with per-task caps, or Make at $9-29/month with operation limits. With Webhook Lead Pusher, most teams spend $1-10/month with no subscription commitment and no task counting.

Push leads to a webhook using the API

Python

from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("ryanclinton/webhook-lead-pusher").call(run_input={
    "webhookUrl": "https://hooks.zapier.com/hooks/catch/1234567/abcdefg/",
    "leads": [
        {
            "firstName": "Sarah",
            "lastName": "Chen",
            "email": "[email protected]",
            "company": "Pinnacle Industries",
            "title": "VP of Engineering"
        }
    ],
    "batchMode": "individual",
    "retryOnFailure": True
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    if item.get("type") == "summary":
        print(f"Delivered: {item['totalDelivered']}, Failed: {item['totalFailed']}")
    else:
        print(f"Lead to {item['webhookUrl']}: {item['status']} ({item['httpStatus']}) in {item['requestDuration']}ms")

JavaScript

import { ApifyClient } from "apify-client";

const client = new ApifyClient({ token: "YOUR_API_TOKEN" });

const run = await client.actor("ryanclinton/webhook-lead-pusher").call({
    webhookUrl: "https://hooks.zapier.com/hooks/catch/1234567/abcdefg/",
    leads: [
        {
            firstName: "Sarah",
            lastName: "Chen",
            email: "[email protected]",
            company: "Pinnacle Industries",
            title: "VP of Engineering"
        }
    ],
    batchMode: "individual",
    retryOnFailure: true
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
for (const item of items) {
    if (item.type === "summary") {
        console.log(`Delivered: ${item.totalDelivered}, Failed: ${item.totalFailed}`);
    } else {
        console.log(`${item.status} → ${item.webhookUrl} (HTTP ${item.httpStatus}, ${item.requestDuration}ms)`);
    }
}

cURL

# Start the actor run
curl -X POST "https://api.apify.com/v2/acts/ryanclinton~webhook-lead-pusher/runs?token=YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "webhookUrl": "https://hooks.zapier.com/hooks/catch/1234567/abcdefg/",
    "leads": [
      {
        "firstName": "Sarah",
        "lastName": "Chen",
        "email": "[email protected]",
        "company": "Pinnacle Industries"
      }
    ],
    "batchMode": "individual",
    "retryOnFailure": true
  }'

# Fetch results (replace DATASET_ID from the run response)
curl "https://api.apify.com/v2/datasets/DATASET_ID/items?token=YOUR_API_TOKEN&format=json"

How Webhook Lead Pusher works

Input validation and URL normalisation

On startup, the actor validates every required field and all webhook URLs using the built-in URL constructor, accepting only http: and https: protocol URLs. Invalid URLs cause an immediate abort with a structured error record in the dataset rather than a silent failure. The leads array is then sliced to maxLeads (default 1,000, hard cap 10,000) before processing begins.

Request batching and payload construction

The actor resolves the delivery mode and constructs request batches accordingly: in individual mode each lead becomes a single-element array; in batch mode all leads form one array; in chunks mode the leads array is sliced into groups of chunkSize. For each batch, the payload is built as follows: if a payloadTemplate is set, the Handlebars-style renderer replaces {{fieldName}} tokens with the string value of that field (or JSON-stringified for non-string types) and {{lead}} with the full JSON of the lead object. Without a template, the actor either wraps leads in {"leads": [...]} (when wrapInPayload is true) or sends the raw object (individual) or raw array (batch/chunks) directly.

HTTP delivery with retry logic

Each batch is sent via the native fetch API with a hard 30-second AbortController timeout. On a successful 2xx response, the delivery is recorded as delivered. On failure, the retry decision follows this logic: 4xx client errors (400, 401, 403, 404, 422) are never retried because they indicate a permanent configuration problem; 5xx server errors and network failures are retried once after a 2-second delay if retryOnFailure is true. Auth errors (401/403) emit a specific log warning. The final status is one of four values: delivered, failed, retried_delivered, or retried_failed, and the full response body (up to 500 characters) is captured for debugging.

Pay-per-event charging and fan-out

Charging occurs only on successful delivery (delivered or retried_delivered) — one lead-pushed event per lead in the batch. If the spending limit ceiling is hit mid-run, the actor records the current position, emits a warning log, and stops processing further batches and endpoints without charging for unprocessed leads. For multi-endpoint fan-out, the full batch sequence is repeated for each URL in allUrls (primary + additional), so each endpoint receives an independent delivery attempt with its own per-endpoint audit records.

Tips for best results

1. Test with httpbin.org/post first. Before pointing at a live CRM or Zapier webhook, set webhookUrl to https://httpbin.org/post. It echoes the exact JSON body you sent back in the response, which appears in the responseBody output field. This confirms your payload shape is correct before you push to production.

2. Match chunk size to your API's documented limits. Most CRM bulk import endpoints accept 50-200 records per request. Set chunkSize to the documented maximum to minimise the number of requests and total run time for large batches.

3. Use individual mode for Zapier and Make. Both platforms process one item per trigger invocation. Sending an array triggers only one zap/scenario regardless of array size. Individual mode ensures each lead fires a separate trigger, which is almost always what you want.

4. Combine with upstream actors in a pipeline. Use Waterfall Contact Enrichment or B2B Lead Gen Suite to enrich leads first, then pass the enriched output directly into this actor's leads field using Apify's dataset chaining.

5. Add a secondary logging endpoint. Put a free webhook.site or RequestBin URL in webhookUrls alongside your primary endpoint. You get an independent record of every payload sent, which is useful for debugging without touching production systems.

6. Keep delayBetweenRequests above 0 for Zapier. Zapier's free and Starter plans have task-per-minute limits. A 500ms delay prevents 429 rate-limit responses on batches over 60 leads.

7. Set maxLeads as a cost guard. If this actor runs on a schedule triggered by a variable upstream dataset, set maxLeads to a known safe ceiling so an unexpectedly large upstream result does not cause an unexpectedly large delivery charge.

Combine with other Apify actors

Actor	How to combine
Website Contact Scraper	Scrape emails and phone numbers from company websites, then push the structured contacts directly to your CRM webhook
Google Maps Email Extractor	Extract local business contacts from Google Maps search results, then deliver the enriched records to a Zapier lead routing zap
Waterfall Contact Enrichment	Run a 10-step enrichment cascade on raw lead data, then use this actor to push the fully enriched contacts to HubSpot or Salesforce
B2B Lead Qualifier	Score leads 0-100 from 30+ signals before delivery; use payloadTemplate to include the score field in the CRM payload
B2B Lead Gen Suite	Complete pipeline from URLs to scored and enriched leads; plug this actor in as the final delivery step
Google Maps Lead Enricher	Full local business pipeline with enrichment; deliver completed records to Slack, HubSpot, or N8N via this actor
HubSpot Lead Pusher	Use HubSpot Lead Pusher for native HubSpot API integration; use Webhook Lead Pusher for all other HTTP endpoints

Limitations

• One payload shape per run. The payloadTemplate applies identically to every lead. If you need different payload structures for different lead types, run the actor twice with different templates.
• No authentication scheme beyond Bearer token. Basic auth, OAuth2 flows, HMAC signature headers, and API key query parameters are not built in. For complex auth, add the signed header manually in headers or use an intermediary service.
• Response body capped at 500 characters. The endpoint's response body is truncated at 500 characters in the output. Very long responses (e.g., full lead records returned by some CRMs) are not fully preserved.
• No conditional fan-out. All leads are sent to all URLs in webhookUrls. There is no filter or routing logic to send different leads to different endpoints based on field values.
• Single retry only. Failed requests are retried once after 2 seconds. Endpoints with intermittent failures or longer recovery windows may still show failures. For high-reliability delivery, pair with a monitoring webhook or a dead-letter queue.
• Template mode processes one lead at a time. payloadTemplate is applied per-lead regardless of batchMode. In chunks or batch mode with a template set, only the first lead of each batch is rendered into the template.
• Leads must be pre-assembled. This actor does not fetch leads from an Apify dataset by ID. You must pass the leads array directly as input. For very large datasets, paginate and run in multiple calls.
• No deduplication. Duplicate leads in the input array are pushed as-is. Deduplicate upstream using Bulk Email Verifier or pre-process the array before passing it.

Integrations

• Zapier — trigger Zaps from each individual lead delivery, sending prospects into email sequences, Slack notifications, or Google Sheets rows
• Make — invoke Make webhook scenarios with lead data to build no-code enrichment and CRM update pipelines
• Google Sheets — pair with a Zapier or Make webhook that appends each incoming lead as a new row in a Google Sheet
• Apify API — chain this actor programmatically after upstream scraping runs using the /runs endpoint, passing the upstream dataset output as the leads input
• Webhooks — configure Apify platform webhooks to notify external systems when this delivery run completes or fails
• LangChain / LlamaIndex — use alongside Website Content to Markdown to build AI-enriched lead pipelines that deliver structured context to LLM-powered CRM agents

Troubleshooting

Delivery status is failed with HTTP 401 or 403. The endpoint rejected the authentication credentials. Check that authToken matches the token your endpoint expects, or verify the correct header name (some APIs use X-API-Key rather than Authorization: Bearer). Set the correct token in authToken or add the full header in the headers object.

Delivery status is failed with HTTP 422. The endpoint received the request but rejected the payload shape. Enable wrapInPayload: false if the endpoint expects a raw object, or define a payloadTemplate that maps your lead fields to the field names the endpoint requires. Test against httpbin.org/post first to confirm the exact payload being sent.

Delivery keeps retrying and failing with 5xx errors. The destination endpoint is temporarily down or overloaded. Increase delayBetweenRequests and re-run. If the endpoint is consistently returning 500 errors, check the responseBody field in the output for error details from the endpoint itself.

N8N webhook triggers only once for a batch. N8N webhook trigger nodes expect a single JSON object per call. Set batchMode: "individual" to send one lead per HTTP request, which fires one N8N execution per lead.

Run completes but fewer leads delivered than expected. Check the summary record (type: "summary") in the dataset for totalFailed. Match each failed record back to a lead using the delivery timestamp sequence. Common causes: rate limiting (increase delayBetweenRequests), payload size too large for the endpoint (reduce chunkSize), or authentication errors on specific requests.

Responsible use

• This actor sends data that you supply to endpoints that you control or have authorisation to access. It does not scrape or access third-party websites.
• Ensure you have a legal basis for processing and transferring the lead data you push, particularly under GDPR, CAN-SPAM, and CASL where applicable.
• Do not use this actor to send unsolicited data to endpoints you do not own or have explicit permission to write to.
• Comply with the terms of service of the platforms you integrate with (Zapier, Make, HubSpot, Salesforce, etc.) regarding automated data ingestion.
• For guidance on data handling and web scraping legality, see Apify's guide.

FAQ

How do I push leads to Zapier using Webhook Lead Pusher? Create a Zapier catch webhook trigger to get your unique hook URL (e.g. https://hooks.zapier.com/hooks/catch/XXXXX/YYYYY/). Paste that URL into webhookUrl, set batchMode to individual, and run the actor. Each lead fires one Zap trigger. The lead fields appear as individual variables in the Zap editor, so you can map email to a CRM contact field, company to an account name, and so on.

How many leads can Webhook Lead Pusher deliver in one run? Up to 10,000 leads per run (enforced by maxLeads). For larger datasets, run the actor in multiple calls and paginate through the input. In individual mode at 200ms delay, 1,000 leads takes approximately 3-4 minutes. In batch mode, 10,000 leads can be delivered in a single HTTP request in under 30 seconds, subject to the endpoint's payload size limit.

Does Webhook Lead Pusher work with Make (formerly Integromat)? Yes. Create a Make webhook module to get a unique scenario URL, paste it into webhookUrl, and set batchMode to individual. Each lead fires one scenario execution. Make's webhook modules parse the incoming JSON body automatically, so all lead fields are immediately available as mappable variables in subsequent modules.

What is the difference between batch mode and chunks mode? Batch mode sends all leads in a single HTTP request as one JSON array. Chunks mode splits the leads into groups of chunkSize and sends each group as a separate request. Use batch when your API accepts large arrays in one call. Use chunks when there is a per-request record limit (e.g., 50 contacts per call) and you need to push more records than that limit.

How does the Handlebars payload template work? Set payloadTemplate to a JSON string containing {{fieldName}} tokens. The actor replaces each token with the corresponding field value from the lead object. String values are inserted directly; non-string values (numbers, objects, arrays) are JSON-stringified. Use {{lead}} to insert the entire lead object as JSON. Example: {"name": "{{firstName}} {{lastName}}", "details": {{lead}}} produces a valid JSON payload with the full lead nested under details.

Is Webhook Lead Pusher free to use? The actor uses pay-per-event pricing at $0.01 per successfully delivered lead. There is no monthly fee and no subscription. Apify's free tier includes $5 of monthly credits, which covers 500 lead deliveries. Failed deliveries are not charged.

How is Webhook Lead Pusher different from using Zapier or Make directly? Zapier and Make charge per task execution ($49-299/month with caps) and require you to manually configure input mapping from Apify datasets. This actor pushes data programmatically within an Apify pipeline — no manual configuration, no task caps, no monthly subscription. You can also fan-out to multiple endpoints simultaneously, which would require separate Zaps or Make scenarios.

What happens if the destination endpoint is down during a run? If the endpoint returns a 5xx error or times out, the actor retries once after 2 seconds (when retryOnFailure is true). If the retry also fails, the lead is counted as failed in the summary and a retried_failed record is written to the dataset. The actor continues to the next lead or batch rather than aborting the run. You will see the exact HTTP status and error message in each failed record.

Can I send leads to multiple endpoints in one run? Yes. Set webhookUrl as your primary endpoint and add additional URLs to the webhookUrls array. The actor delivers the full lead set to each endpoint sequentially. Each endpoint gets its own set of delivery result records in the dataset, so you can verify per-endpoint success independently.

Is it legal to push scraped lead data to webhooks and CRMs? The legality depends on the source of the lead data, not the delivery mechanism. You are responsible for ensuring the data you pass to this actor was collected lawfully and that you have a legal basis for processing and transferring it. For B2B contact data, the primary frameworks to consider are GDPR (EU), CAN-SPAM (US), and CASL (Canada). See Apify's guide on web scraping legality for a detailed overview.

Can I schedule this actor to run on a recurring basis? Yes. Use Apify's built-in scheduler to run the actor daily, weekly, or on any cron schedule. Combine with an upstream scraping actor (e.g., Website Contact Scraper) that populates a dataset, then use the Apify API to fetch fresh leads and pass them as input to a scheduled delivery run. This creates a fully automated lead generation and delivery pipeline.

Help us improve

If you encounter issues, you can help us debug faster by enabling run sharing in your Apify account:

1. Go to Account Settings > Privacy
2. Enable Share runs with public Actor creators

This lets us see your run details when something goes wrong, so we can fix issues faster. Your data is only visible to the actor developer, not publicly.

Support

Found a bug or have a feature request? Open an issue in the Issues tab on this actor's page. For custom solutions or enterprise integrations, reach out through the Apify platform.