# Webhook Lead Pusher — Send Enriched Leads to Any Endpoint (`ryanclinton/webhook-lead-pusher`) Actor Push enriched leads to any HTTP webhook — Zapier, Make, N8N, HubSpot, Salesforce, or custom APIs. Individual, batch, or chunked delivery with retry logic, custom headers, Bearer auth, and fan-out to multiple endpoints. $0.01/lead. - **URL**: https://apify.com/ryanclinton/webhook-lead-pusher.md - **Developed by:** [ryan clinton](https://apify.com/ryanclinton) (community) - **Categories:** Other - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks - **User rating**: No ratings yet ## Pricing Pay per usage This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have. Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage ## What's an Apify Actor? Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases. 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. Actors are written with capital "A". ## 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. The best way to integrate Actors is as follows. In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md): ```bash npm install apify-client ``` In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md): ```bash pip install apify-client ``` In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md): ````bash # MacOS / Linux curl -fsSL https://apify.com/install-cli.sh | bash # Windows irm https://apify.com/install-cli.ps1 | iex ```bash In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md). If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md). For usage examples, see the [API](#api) section below. For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt). # README ## 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](https://apify.com/ryanclinton/website-contact-scraper), [Google Maps Email Extractor](https://apify.com/ryanclinton/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 | `sarah.chen@pinnacle-industries.com` | | 👤 **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](https://apify.com/ryanclinton/website-contact-scraper) or [Google Maps Lead Enricher](https://apify.com/ryanclinton/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](https://apify.com/ryanclinton/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):** ```json { "webhookUrl": "https://hooks.zapier.com/hooks/catch/1234567/abcdefg/", "leads": [ { "firstName": "Sarah", "lastName": "Chen", "email": "sarah.chen@pinnacle-industries.com", "company": "Pinnacle Industries", "title": "VP of Engineering", "phone": "+1-415-555-0182" }, { "firstName": "Marcus", "lastName": "Webb", "email": "m.webb@deltalogistics.io", "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:** ```json { "webhookUrl": "https://api.mycrm.com/v2/contacts/bulk", "webhookUrls": [ "https://hooks.zapier.com/hooks/catch/1234567/backup/" ], "leads": [ { "firstName": "Priya", "lastName": "Nair", "email": "priya.nair@vortextech.com", "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:** ```json { "webhookUrl": "https://httpbin.org/post", "leads": [ { "email": "test@example.com", "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 ```json { "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: ```json { "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 ```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": "sarah.chen@pinnacle-industries.com", "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 ```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: "sarah.chen@pinnacle-industries.com", 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 ```bash ## 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": "sarah.chen@pinnacle-industries.com", "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](https://apify.com/ryanclinton/waterfall-contact-enrichment) or [B2B Lead Gen Suite](https://apify.com/ryanclinton/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](https://apify.com/ryanclinton/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](https://apify.com/ryanclinton/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](https://apify.com/ryanclinton/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](https://apify.com/ryanclinton/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](https://apify.com/ryanclinton/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](https://apify.com/ryanclinton/google-maps-lead-enricher) | Full local business pipeline with enrichment; deliver completed records to Slack, HubSpot, or N8N via this actor | | [HubSpot Lead Pusher](https://apify.com/ryanclinton/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](https://apify.com/ryanclinton/bulk-email-verifier) or pre-process the array before passing it. ### Integrations - [Zapier](https://apify.com/integrations/zapier) — trigger Zaps from each individual lead delivery, sending prospects into email sequences, Slack notifications, or Google Sheets rows - [Make](https://apify.com/integrations/make) — invoke Make webhook scenarios with lead data to build no-code enrichment and CRM update pipelines - [Google Sheets](https://apify.com/integrations/google-sheets) — pair with a Zapier or Make webhook that appends each incoming lead as a new row in a Google Sheet - [Apify API](https://docs.apify.com/api/v2) — chain this actor programmatically after upstream scraping runs using the `/runs` endpoint, passing the upstream dataset output as the `leads` input - [Webhooks](https://docs.apify.com/platform/integrations/webhooks) — configure Apify platform webhooks to notify external systems when this delivery run completes or fails - [LangChain / LlamaIndex](https://docs.apify.com/platform/integrations) — use alongside [Website Content to Markdown](https://apify.com/ryanclinton/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](https://blog.apify.com/is-web-scraping-legal/). ### 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](https://blog.apify.com/is-web-scraping-legal/) 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](https://apify.com/ryanclinton/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](https://console.apify.com/account/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](https://console.apify.com/actors/ryanclinton~webhook-lead-pusher/issues) on this actor's page. For custom solutions or enterprise integrations, reach out through the Apify platform. # Actor input Schema ## `webhookUrl` (type: `string`): Primary HTTP(S) endpoint to POST leads to (e.g. a Zapier webhook, Make scenario URL, or custom API endpoint). ## `leads` (type: `array`): Array of enriched lead objects to push. Each object can have any fields (name, email, company, phone, etc.). ## `webhookUrls` (type: `array`): Optional additional endpoints to fan-out leads to. Leads will be sent to ALL URLs (primary + additional). ## `method` (type: `string`): HTTP method to use when pushing leads. ## `headers` (type: `object`): Additional HTTP headers to include in every request (e.g. {"X-API-Key": "your-key", "X-Source": "apify"}). Content-Type: application/json is always set automatically. ## `authToken` (type: `string`): Bearer token for authentication. Sent as Authorization: Bearer {token}. Use this instead of putting the token in custom headers. ## `batchMode` (type: `string`): How to group leads into HTTP requests. Individual: one request per lead. Batch: all leads in one request. Chunks: leads split into groups of chunkSize. ## `chunkSize` (type: `integer`): Number of leads per request when using Chunks mode. ## `wrapInPayload` (type: `boolean`): When enabled, leads are sent as {"leads": \[...]}. When disabled, the raw lead object (individual mode) or raw array (batch/chunks) is sent directly. ## `payloadTemplate` (type: `string`): Optional custom payload template. Use {{fieldName}} to inject lead field values and {{lead}} for the full lead as JSON. Example: {"contact": "{{firstName}} {{lastName}}", "data": {{lead}}}. Overrides wrapInPayload when set. ## `retryOnFailure` (type: `boolean`): Retry failed requests once after a 2-second delay. 5xx errors and network timeouts are retried. 4xx client errors are not retried. ## `maxLeads` (type: `integer`): Maximum number of leads to process from the input array. ## `delayBetweenRequests` (type: `integer`): Milliseconds to wait between HTTP requests in Individual and Chunks modes. Use this to avoid rate-limiting on the destination endpoint. ## Actor input object example ```json { "webhookUrl": "https://hooks.zapier.com/hooks/catch/123456/abcdef/", "leads": [ { "firstName": "Sarah", "lastName": "Chen", "email": "sarah.chen@acmecorp.com", "company": "Acme Corp", "title": "VP of Engineering", "phone": "+1-415-555-0182", "linkedinUrl": "https://linkedin.com/in/sarahchen" } ], "method": "POST", "batchMode": "individual", "chunkSize": 50, "wrapInPayload": true, "retryOnFailure": true, "maxLeads": 1000, "delayBetweenRequests": 200 } ``` # 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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "webhookUrl": "https://hooks.zapier.com/hooks/catch/123456/abcdef/", "leads": [ { "firstName": "Sarah", "lastName": "Chen", "email": "sarah.chen@acmecorp.com", "company": "Acme Corp", "title": "VP of Engineering", "phone": "+1-415-555-0182", "linkedinUrl": "https://linkedin.com/in/sarahchen" } ] }; // Run the Actor and wait for it to finish const run = await client.actor("ryanclinton/webhook-lead-pusher").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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "webhookUrl": "https://hooks.zapier.com/hooks/catch/123456/abcdef/", "leads": [{ "firstName": "Sarah", "lastName": "Chen", "email": "sarah.chen@acmecorp.com", "company": "Acme Corp", "title": "VP of Engineering", "phone": "+1-415-555-0182", "linkedinUrl": "https://linkedin.com/in/sarahchen", }], } # Run the Actor and wait for it to finish run = client.actor("ryanclinton/webhook-lead-pusher").call(run_input=run_input) # Fetch and print Actor results from the run's dataset (if there are any) print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"]) for item in client.dataset(run["defaultDatasetId"]).iterate_items(): print(item) # 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start ``` ## CLI example ```bash echo '{ "webhookUrl": "https://hooks.zapier.com/hooks/catch/123456/abcdef/", "leads": [ { "firstName": "Sarah", "lastName": "Chen", "email": "sarah.chen@acmecorp.com", "company": "Acme Corp", "title": "VP of Engineering", "phone": "+1-415-555-0182", "linkedinUrl": "https://linkedin.com/in/sarahchen" } ] }' | apify call ryanclinton/webhook-lead-pusher --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "command": "npx", "args": [ "mcp-remote", "https://mcp.apify.com/?tools=ryanclinton/webhook-lead-pusher", "--header", "Authorization: Bearer " ] } } } ``` ## OpenAPI specification ```json { "openapi": "3.0.1", "info": { "title": "Webhook Lead Pusher — Send Enriched Leads to Any Endpoint", "description": "Push enriched leads to any HTTP webhook — Zapier, Make, N8N, HubSpot, Salesforce, or custom APIs. Individual, batch, or chunked delivery with retry logic, custom headers, Bearer auth, and fan-out to multiple endpoints. $0.01/lead.", "version": "1.0", "x-build-id": "WSzvcl70XNSRewp2v" }, "servers": [ { "url": "https://api.apify.com/v2" } ], "paths": { "/acts/ryanclinton~webhook-lead-pusher/run-sync-get-dataset-items": { "post": { "operationId": "run-sync-get-dataset-items-ryanclinton-webhook-lead-pusher", "x-openai-isConsequential": false, "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK" } } } }, "/acts/ryanclinton~webhook-lead-pusher/runs": { "post": { "operationId": "runs-sync-ryanclinton-webhook-lead-pusher", "x-openai-isConsequential": false, "summary": "Executes an Actor and returns information about the initiated run in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK", "content": { "application/json": { "schema": { "$ref": "#/components/schemas/runsResponseSchema" } } } } } } }, "/acts/ryanclinton~webhook-lead-pusher/run-sync": { "post": { "operationId": "run-sync-ryanclinton-webhook-lead-pusher", "x-openai-isConsequential": false, "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK" } } } } }, "components": { "schemas": { "inputSchema": { "type": "object", "required": [ "webhookUrl", "leads" ], "properties": { "webhookUrl": { "title": "Webhook URL", "type": "string", "description": "Primary HTTP(S) endpoint to POST leads to (e.g. a Zapier webhook, Make scenario URL, or custom API endpoint).", "default": "https://httpbin.org/post" }, "leads": { "title": "Leads", "type": "array", "description": "Array of enriched lead objects to push. Each object can have any fields (name, email, company, phone, etc.).", "default": [ { "firstName": "Sarah", "lastName": "Chen", "email": "sarah.chen@acmecorp.com", "company": "Acme Corp", "title": "VP of Engineering", "phone": "+1-415-555-0182", "linkedinUrl": "https://linkedin.com/in/sarahchen" } ] }, "webhookUrls": { "title": "Additional Webhook URLs", "type": "array", "description": "Optional additional endpoints to fan-out leads to. Leads will be sent to ALL URLs (primary + additional).", "items": { "type": "string" } }, "method": { "title": "HTTP Method", "enum": [ "POST", "PUT", "PATCH" ], "type": "string", "description": "HTTP method to use when pushing leads.", "default": "POST" }, "headers": { "title": "Custom Headers", "type": "object", "description": "Additional HTTP headers to include in every request (e.g. {\"X-API-Key\": \"your-key\", \"X-Source\": \"apify\"}). Content-Type: application/json is always set automatically." }, "authToken": { "title": "Auth Token (Bearer)", "type": "string", "description": "Bearer token for authentication. Sent as Authorization: Bearer {token}. Use this instead of putting the token in custom headers." }, "batchMode": { "title": "Batch Mode", "enum": [ "individual", "batch", "chunks" ], "type": "string", "description": "How to group leads into HTTP requests. Individual: one request per lead. Batch: all leads in one request. Chunks: leads split into groups of chunkSize.", "default": "individual" }, "chunkSize": { "title": "Chunk Size", "minimum": 1, "maximum": 1000, "type": "integer", "description": "Number of leads per request when using Chunks mode.", "default": 50 }, "wrapInPayload": { "title": "Wrap in Payload Envelope", "type": "boolean", "description": "When enabled, leads are sent as {\"leads\": [...]}. When disabled, the raw lead object (individual mode) or raw array (batch/chunks) is sent directly.", "default": true }, "payloadTemplate": { "title": "Payload Template (Handlebars-style)", "type": "string", "description": "Optional custom payload template. Use {{fieldName}} to inject lead field values and {{lead}} for the full lead as JSON. Example: {\"contact\": \"{{firstName}} {{lastName}}\", \"data\": {{lead}}}. Overrides wrapInPayload when set." }, "retryOnFailure": { "title": "Retry on Failure", "type": "boolean", "description": "Retry failed requests once after a 2-second delay. 5xx errors and network timeouts are retried. 4xx client errors are not retried.", "default": true }, "maxLeads": { "title": "Max Leads", "minimum": 1, "maximum": 10000, "type": "integer", "description": "Maximum number of leads to process from the input array.", "default": 1000 }, "delayBetweenRequests": { "title": "Delay Between Requests (ms)", "minimum": 0, "maximum": 30000, "type": "integer", "description": "Milliseconds to wait between HTTP requests in Individual and Chunks modes. Use this to avoid rate-limiting on the destination endpoint.", "default": 200 } } }, "runsResponseSchema": { "type": "object", "properties": { "data": { "type": "object", "properties": { "id": { "type": "string" }, "actId": { "type": "string" }, "userId": { "type": "string" }, "startedAt": { "type": "string", "format": "date-time", "example": "2025-01-08T00:00:00.000Z" }, "finishedAt": { "type": "string", "format": "date-time", "example": "2025-01-08T00:00:00.000Z" }, "status": { "type": "string", "example": "READY" }, "meta": { "type": "object", "properties": { "origin": { "type": "string", "example": "API" }, "userAgent": { "type": "string" } } }, "stats": { "type": "object", "properties": { "inputBodyLen": { "type": "integer", "example": 2000 }, "rebootCount": { "type": "integer", "example": 0 }, "restartCount": { "type": "integer", "example": 0 }, "resurrectCount": { "type": "integer", "example": 0 }, "computeUnits": { "type": "integer", "example": 0 } } }, "options": { "type": "object", "properties": { "build": { "type": "string", "example": "latest" }, "timeoutSecs": { "type": "integer", "example": 300 }, "memoryMbytes": { "type": "integer", "example": 1024 }, "diskMbytes": { "type": "integer", "example": 2048 } } }, "buildId": { "type": "string" }, "defaultKeyValueStoreId": { "type": "string" }, "defaultDatasetId": { "type": "string" }, "defaultRequestQueueId": { "type": "string" }, "buildNumber": { "type": "string", "example": "1.0.0" }, "containerUrl": { "type": "string" }, "usage": { "type": "object", "properties": { "ACTOR_COMPUTE_UNITS": { "type": "integer", "example": 0 }, "DATASET_READS": { "type": "integer", "example": 0 }, "DATASET_WRITES": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_READS": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_WRITES": { "type": "integer", "example": 1 }, "KEY_VALUE_STORE_LISTS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_READS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_WRITES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_INTERNAL_GBYTES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_EXTERNAL_GBYTES": { "type": "integer", "example": 0 }, "PROXY_RESIDENTIAL_TRANSFER_GBYTES": { "type": "integer", "example": 0 }, "PROXY_SERPS": { "type": "integer", "example": 0 } } }, "usageTotalUsd": { "type": "number", "example": 0.00005 }, "usageUsd": { "type": "object", "properties": { "ACTOR_COMPUTE_UNITS": { "type": "integer", "example": 0 }, "DATASET_READS": { "type": "integer", "example": 0 }, "DATASET_WRITES": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_READS": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_WRITES": { "type": "number", "example": 0.00005 }, "KEY_VALUE_STORE_LISTS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_READS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_WRITES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_INTERNAL_GBYTES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_EXTERNAL_GBYTES": { "type": "integer", "example": 0 }, "PROXY_RESIDENTIAL_TRANSFER_GBYTES": { "type": "integer", "example": 0 }, "PROXY_SERPS": { "type": "integer", "example": 0 } } } } } } } } } } ```