Webhooks push DataSift events to your own systems as they happen, so you don't have to poll. Use them to feed a CRM, a dialer or SMS tool, an automation platform (Zapier, Make, n8n, Pipedream), an AI agent, or your own backend.
Webhooks are outbound and account-level. DataSift sends an HTTPS POST with a JSON body to an endpoint you control.
- You add a webhook in the DataSift app.
- In Sequence Builder, you add the Send a webhook action and pick that webhook.
- Each time a sequence reaches that action for a property, DataSift sends a
sequence.action.triggeredevent to your endpoint with the sequence and property context.
Combine the webhook action with other sequence actions, for example "status changed to Hot Lead" → send a webhook and create a follow-up task.
| Event | When it's sent |
|---|---|
sequence.action.triggered | A sequence reached a Send a webhook action for a property. |
webhook.test | You sent a test delivery from the app. Dummy data in the same shape as a real event. |
More event types will be added over time; see the changelog. Your endpoint should ignore event types it does not handle.
- Create the receiving endpoint in your tool (for example, a Zapier "Catch Hook" or an n8n Webhook node) and copy its URL.
- In DataSift, go to Settings → Integrations → Webhooks and select Add Webhook. Enter a name, paste the URL, and save.
- Select Test to send a
webhook.testdelivery and confirm your endpoint returns200. - Open Sequence Builder, add the Send a webhook action to a sequence, and choose your webhook from the list. Only active webhooks are listed.
Add and manage webhooks in the DataSift app before you add the action to a sequence. Creating and managing webhooks requires the Super Admin or Sensei role; anyone with access to Sequence Builder can use an existing webhook in a sequence.
If your endpoint requires a credential, configure it when setting up the webhook in the DataSift app. DataSift sends it with every delivery:
auth.type | Fields you send | Header DataSift sends |
|---|---|---|
none (default) | none | none |
basic | username, secret | Authorization: Basic <base64 of username:secret> |
bearer | secret | Authorization: Bearer <secret> |
api_key | header, secret | <header>: <secret> |
Every delivery is signed with Ed25519. Verifying is optional, but it's the only way to know a request really came from DataSift and wasn't modified.
| Header | Example | Meaning |
|---|---|---|
X-Sift-Webhook-Signature | v1,7mJ2...== | Signature version, then the base64 Ed25519 signature |
X-Sift-Webhook-Timestamp | 1786742400 | Unix seconds when the delivery was signed |
X-Sift-Webhook-Key-Id | k1 | Which public key verifies the signature |
The signature covers this exact byte string:
{timestamp}.{raw_request_body}Use the raw request body as received. Parsing and re-serializing the JSON changes key order and whitespace, and the signature won't match.
Get the public keys from GET https://apiv2.reisift.io/webhook/signing-keys/ (no Authorization header). Pick the key whose key_id matches the X-Sift-Webhook-Key-Id header, cache the response, and refetch when you see a key_id you don't have. During a key rotation both keys are returned, with status active or additional; treat both as valid.
{
"keys": [
{
"key_id": "k1",
"algorithm": "ed25519",
"status": "active",
"public_key": "-----BEGIN PUBLIC KEY-----\n...\n-----END PUBLIC KEY-----\n"
}
],
"signature_header": "X-Sift-Webhook-Signature",
"timestamp_header": "X-Sift-Webhook-Timestamp",
"key_id_header": "X-Sift-Webhook-Key-Id",
"signed_payload_format": "{timestamp}.{raw_request_body}",
"signature_version": "v1"
}Node.js:
const crypto = require("crypto");
const [version, signature] = req.headers["x-sift-webhook-signature"].split(",");
const timestamp = Number(req.headers["x-sift-webhook-timestamp"]);
const ok = crypto.verify(
null, // Ed25519 takes no separate digest
Buffer.concat([Buffer.from(`${timestamp}.`), req.rawBody]),
crypto.createPublicKey(publicKeyPem),
Buffer.from(signature, "base64"),
);Python:
import base64
from cryptography.exceptions import InvalidSignature
from cryptography.hazmat.primitives.serialization import load_pem_public_key
version, _, signature = headers["X-Sift-Webhook-Signature"].partition(",")
timestamp = int(headers["X-Sift-Webhook-Timestamp"])
try:
load_pem_public_key(public_key_pem.encode()).verify(
base64.b64decode(signature),
f"{timestamp}.".encode() + raw_body,
)
except InvalidSignature:
reject()The timestamp is part of the signed string, so a captured delivery can't be re-dated. Reject deliveries whose timestamp is too old; allow at least 15 minutes so retries still pass.
Each delivery is a JSON object with event metadata, the sequence that fired, and the property the action ran for. Illustrative example (values are fictitious):
{
"event_type": "sequence.action.triggered",
"event_id": "1b9f0c2e-6a51-4c8e-9f3d-2f1e7c4a9b10",
"event_datetime": "2026-11-02T14:05:31Z",
"sequence": {
"uuid": "6c0b1d8a-2f4e-4a7b-9c1d-3e5f7a9b1c2d",
"name": "Absentee Owner Follow-up"
},
"property": {
"uuid": "73e52854-ebb2-55a3-8768-f78cf98a4897",
"address": {"street": "123 Main St", "city": "Columbus", "state": "OH", "postal_code": "43207"},
"owner": {"first_name": "Jane", "last_name": "Doe"},
"tags": ["FTM"],
"lists": ["Foreclosure 2026-07"]
}
}The property object carries the same fields as the record in the API. Use the app's Test button to see the exact payload for your account, and build your parser to ignore fields it doesn't know so new fields don't break it.
- Respond with any
2xxstatus within a few seconds. Do slow work after you respond (queue it). - A failed delivery (network error, timeout, or non-
2xx) is retried up to 3 times with exponential backoff. If your endpoint returns aRetry-Afterheader, DataSift honors it for up to 15 minutes. - A failed delivery never stops the rest of the sequence.
- Deliveries can arrive more than once or out of order. Use
event_idto skip duplicates. - Deliveries are rate-capped per account to protect your endpoint and the platform.
| Symptom | Check |
|---|---|
| Test fails | The URL is HTTPS and public, the endpoint returns 2xx, and any auth credential is current. |
| Signature never matches | You verify against the raw body, include the {timestamp}. prefix, and use the key matching X-Sift-Webhook-Key-Id. |
| No deliveries | The webhook is enabled, the sequence is active, and its trigger and conditions match your records. |
| Duplicates | Deduplicate on event_id. |