67Leads webhooks

A webhook posts your leads as JSON to an HTTPS URL you choose, every time you export and every time a saved search finds new matches. Each request is signed with your account's secret so your endpoint can check it came from 67Leads. Webhooks are available on every paid plan, including the $6.70 pack (1,000 leads).

Set it up

  1. In the app, open Integrations, then Webhook.
  2. Paste your endpoint URL, tick the events you want, and press Turn on webhook.
  3. Copy the signing secret shown under the URL. Press Send test to post a ping event to your endpoint.

What is sent

One POST per delivery, Content-Type: application/json, with these headers:

HeaderValue
X-67Leads-Signaturet=<unix seconds>,v1=<hex>, see below.
X-67Leads-Eventexport.completed, alert.new_leads or ping.
X-67Leads-DeliveryAn id like dlv_1042. It is the same on every retry of one delivery, so dedupe on it.
X-67Leads-TimestampUnix seconds of this attempt, the same number as t= in the signature.
User-Agent67Leads-Webhooks/1.0 (+https://67leads.com/docs/webhooks)

The body is a JSON object with id, event, created_at and data. You choose which of two events your webhook takes, export and alert; both are on by default. The event field and the X-67Leads-Event header carry the longer names below.

Export: export.completed

Sent for every export, whether it started in the app, the HTTP API, the MCP server or a send to a sequencer. It carries the leads in that export, in the same columns as a CSV export in the default layout, whichever layout the file used. Large exports are split into batches of up to 500 leads, one POST each: batch counts from 1 up to batches. rows_total is the whole export; new_total is how many of its leads were new to your account.

{
  "id": "dlv_1042",
  "event": "export.completed",
  "created_at": "2026-11-16T15:04:05+00:00",
  "data": {
    "export_id": "export:3fa85f64b2c1",
    "channel": "http",
    "preset": "67leads",
    "rows_total": 1200,
    "new_total": 800,
    "batch": 1,
    "batches": 3,
    "leads": [
      {
        "company": "Example Roofing Co",
        "owner_name": "Sam Example",
        "phone_e164": "+12145550100",
        "email": "owner@example.com",
        "email_status": "valid",
        "website": "https://example.com",
        "city": "Dallas",
        "state": "TX",
        "category": "roofing",
        "rating": 4.6,
        "review_count": 87,
        "...": "every other export column"
      }
    ]
  }
}

The example shows some of the columns; the real objects carry every export column, the ones the Sheets feed page lists.

Alert: alert.new_leads

Sent once per saved search when the hourly check finds new matches. The leads are masked: company, place, trade, rating and review count, plus has_email, has_phone and has_website flags. There is no email, phone number, owner or website in the payload, because you do not own those leads yet; open the search in the app, or export, to get them. At most 100 leads are included per POST; new_count is always the full number and leads_included says how many are in this body.

{
  "id": "dlv_1043",
  "event": "alert.new_leads",
  "created_at": "2026-11-16T16:00:12+00:00",
  "data": {
    "saved_search": {
      "id": 7,
      "name": "Roofers in Dallas",
      "app_url": "https://67leads.com/app?..."
    },
    "since": "2026-11-16T15:00:03+00:00",
    "new_count": 14,
    "leads_included": 14,
    "masked": true,
    "leads": [
      {
        "id": 5551234,
        "company": "Example Roofing Co",
        "city": "Dallas",
        "state": "TX",
        "vertical": "roofing",
        "category": "Roofing contractor",
        "rating": 4.6,
        "review_count": 87,
        "has_email": true,
        "has_phone": true,
        "has_website": false,
        "first_seen": "2026-11-16"
      }
    ]
  }
}

Verify the signature

The X-67Leads-Signature header is t=<timestamp>,v1=<signature>. The signature is the hex HMAC-SHA256 of the string <timestamp>.<raw body> (the timestamp, a full stop, then the body bytes exactly as received), keyed with your signing secret. To check a request:

  1. Read the raw body before any JSON parsing; re-serialised JSON will not match.
  2. Split the header into t and v1.
  3. Compute the HMAC over t + "." + body and compare it to v1 with a constant-time comparison.
  4. Reject a timestamp that is too old. 5 minutes (300 seconds) is a sensible window; that number is our recommendation and 67Leads does not enforce it. Each retry is signed fresh with the time of that attempt, so a late retry still passes the same check.

Python

import hashlib, hmac, time

TOLERANCE = 300  # seconds. Our recommendation, not enforced by 67Leads.

def verify(secret: str, header: str, raw_body: bytes) -> bool:
    """header is the X-67Leads-Signature value; raw_body is the bytes as received."""
    try:
        parts = dict(p.split("=", 1) for p in header.split(","))
        ts, sent = parts["t"], parts["v1"]
        age = abs(time.time() - int(ts))
    except (KeyError, ValueError):
        return False
    if age > TOLERANCE:
        return False
    expected = hmac.new(secret.encode(), ts.encode() + b"." + raw_body,
                        hashlib.sha256).hexdigest()
    return hmac.compare_digest(expected, sent)

Node

const crypto = require("crypto");

const TOLERANCE = 300; // seconds. Our recommendation, not enforced by 67Leads.

// rawBody must be the Buffer exactly as received (express.raw), not re-serialised JSON.
function verify(secret, header, rawBody) {
  const parts = {};
  for (const piece of header.split(",")) {
    const i = piece.indexOf("=");
    if (i > 0) parts[piece.slice(0, i)] = piece.slice(i + 1);
  }
  const ts = parts.t, sent = parts.v1;
  if (!ts || !sent || Math.abs(Date.now() / 1000 - Number(ts)) > TOLERANCE) return false;
  const expected = crypto.createHmac("sha256", secret)
    .update(`${ts}.`).update(rawBody).digest("hex");
  const a = Buffer.from(expected), b = Buffer.from(sent);
  return a.length === b.length && crypto.timingSafeEqual(a, b);
}

// app.post("/67leads", express.raw({ type: "application/json" }), (req, res) => {
//   if (!verify(process.env.LEADS67_SECRET, req.get("X-67Leads-Signature") || "", req.body))
//     return res.sendStatus(400);
//   const event = JSON.parse(req.body);
//   res.sendStatus(200);
// });

Replies and retries

Answer with any 2xx status within 10 seconds. 67Leads follows up to 3 redirects, each to an HTTPS URL. Anything else (another status, a timeout, a connection or certificate error) counts as a failed attempt. After a failed attempt the delivery is tried again after 1m, 5m, 30m, 2h, 6h, in that order. After attempt number 6 it is marked failed and kept in the delivery log in the Integrations panel. The ping from Send test is never retried.

Which URLs are accepted

The URL must start with https://, must not contain a username or password, and must be on the public internet: private and internal addresses and names such as localhost or .local are refused, both when you save it and on every send (67Leads resolves the name itself and refuses the delivery if any address is private). If a service wants credentials, put a token in the path or query string. The URL can be at most 500 characters.

Rotate the signing secret

In Integrations, Webhook, press Rotate next to the signing secret. The new secret is shown at once and signs every delivery from then on, including retries of deliveries already queued, so update your endpoint's secret first or accept a short gap. Changing the endpoint URL keeps the secret.

Use with Zapier, Make or n8n

These three work through their generic webhook trigger, with no native 67Leads app. The steps are the same in each.

Use with Zapier

67Leads has no native Zapier app. Zapier takes the webhook through its generic webhook trigger: a Zap whose trigger is Webhooks by Zapier, event Catch Hook, which gives you a unique URL. Paste that URL into the Endpoint URL box in 67Leads (Integrations, Webhook), choose the events, and press Send test so Zapier sees a sample. Zapier does not check the signature for you; a catch hook accepts any request to its URL. Zapier's own page for this trigger: Zapier: Trigger Zap workflows from webhooks.

Use with Make

67Leads has no native Make app. Make takes the webhook through its generic webhook trigger: a scenario that starts with a Custom webhook module, which gives you a unique URL. Paste that URL into the Endpoint URL box in 67Leads (Integrations, Webhook), choose the events, and press Send test so Make sees a sample. Make's page describes custom webhooks as a URL that accepts any data, and points to the Webhooks app page for the module's own setup. Make's own page for this trigger: Make: Webhooks.

Use with n8n

67Leads has no native n8n app. n8n takes the webhook through its generic webhook trigger: a workflow that starts with the Webhook node, set to POST. Use its production URL once the workflow is published. Paste that URL into the Endpoint URL box in 67Leads (Integrations, Webhook), choose the events, and press Send test so n8n sees a sample. To verify the signature inside n8n, use a Code node with the Node sample above on the raw body. n8n's own page for this trigger: n8n: Webhook node.

Third-party pages checked 16 Nov 2026; the tools may change their screens.

Google Maps leads to Google SheetsIntegrationsHTTP APIPricing

Questions

Who can use webhooks?

Webhooks are available on every paid plan, including the $6.70 pack (1,000 leads). A free account can search and use its welcome leads, but cannot register a webhook.

Does 67Leads have a Zapier, Make or n8n app?

No. Use the generic webhook trigger in each tool and paste its URL into the Integrations panel.

What happens if my endpoint is down?

The delivery is retried after 1m, 5m, 30m, 2h, 6h, then marked failed and kept in the log.

How do I stop duplicates when a delivery is retried?

Store the X-67Leads-Delivery value. It is the same on every retry of one delivery.

Does the alert webhook send contact details?

No. Alert leads are masked: company, place, trade, rating and flags for whether an email, phone or website exists.