A form webhook is where an inquiry leaves the form tool and becomes a Slack message, a sheet row, or a CRM deal. When it fires twice you get two deals. When it isn't signed, anyone who finds the URL can post fake leads. When it fails quietly, a client who filled in your form never hears back.
Before you wire a form into operations, check what the webhook actually gives you. Below is a checklist you can use with any form builder, a short Node snippet for signature verification that we tested before publishing, the receiving side in n8n, and how Dashform answers each item, including the ones it doesn't cover.
The checklist
Copy this table into your evaluation doc and fill in the right-hand column for each tool you're considering.
| Item | What to look for | What you do on your side | Tool's answer |
|---|---|---|---|
| Stable submission ID | An ID per submission that never changes, in every payload | Use it as the primary key in your sheet or CRM | |
| Idempotency key | A header or field that stays the same across retries of one delivery | Store it with a unique constraint; skip repeats | |
| Signature | An HMAC of the raw body with a secret you set, documented header format | Verify before parsing; reject on mismatch | |
| Retry schedule | Documented retry timing and which status codes trigger a retry | Return 2xx fast once the payload is stored | |
| Replay | A way to resend a failed delivery without the client resubmitting | Make your handler safe to run twice | |
| Delivery log | Status, attempt count, and last error per delivery | Check it when a record is missing | |
| Schema version | A version field and a stated rule for breaking changes | Alert on an unknown version | |
| Form revision | Which version of the questions produced the submission | Map fields per revision, not per form | |
| Field keys | Answers keyed by a stable key, not the question label | Map on keys so renaming a question is safe | |
| Uploaded files | How files are delivered, who can open them, what deletion removes | Copy files you must keep; don't forward public links widely | |
| Test path | A way to send test submissions without polluting real data | Use a separate endpoint and clean up after |
Why each item matters
A stable submission ID
Without a permanent ID, the only way to tell whether two rows are the same inquiry is to compare names and emails, which breaks the first time a client submits twice on purpose. A stable ID in every payload lets you update the existing row instead of guessing.
An idempotency key, and how to dedupe on it
Webhook senders retry, and a retry can arrive even when your first response succeeded but was lost on the way back. Stripe's webhook docs say endpoints "might occasionally receive the same event more than once" and recommend logging processed event IDs.
The reliable pattern is to insert the key into a table with a unique constraint before doing any work. If the insert fails because the key exists, return 2xx and stop. Keeping a list in memory works for a demo, not across restarts.
A signature over the raw body
A webhook URL is a public endpoint. A signature proves the request came from the sender and wasn't changed. The sender computes an HMAC of the request body with a secret only the two of you know, and you compute the same thing on arrival.
Compute it over the raw bytes exactly as received. If your framework parses the JSON first and you re-serialize it, spacing or escaping can change and the signature won't match; Stripe warns that "any manipulation to the raw body" causes verification to fail. Compare with a constant-time function rather than ==, as GitHub's guide to validating deliveries recommends.
Here is a minimal receiver in Node with no dependencies. It verifies an X-Dashform-Signature: sha256=<hex> header, dedupes on the Idempotency-Key header, and answers 2xx. Before publishing we ran it on Node 24: a correctly signed sample body returned 200, the same delivery sent again was skipped, and a wrong signature returned 401.
import { createHmac, timingSafeEqual } from "node:crypto";
import { createServer } from "node:http";
const secret = process.env.DASHFORM_WEBHOOK_SECRET;
const seen = new Set(); // in production: a table with a unique key
function verifySignature(rawBody, header, secret) {
if (typeof header !== "string") return false;
const expected =
"sha256=" + createHmac("sha256", secret).update(rawBody).digest("hex");
const a = Buffer.from(header);
const b = Buffer.from(expected);
return a.length === b.length && timingSafeEqual(a, b);
}
createServer((req, res) => {
const chunks = [];
req.on("data", (chunk) => chunks.push(chunk));
req.on("end", () => {
const rawBody = Buffer.concat(chunks);
if (
!verifySignature(rawBody, req.headers["x-dashform-signature"], secret)
) {
res.writeHead(401).end();
return;
}
const key = req.headers["idempotency-key"];
if (seen.has(key)) {
res.writeHead(200).end();
return;
}
const reply = JSON.parse(rawBody.toString("utf8"));
seen.add(key);
// queue the reply for Slack, the sheet, or the CRM here
console.log(reply.replyId, reply.formRevisionId);
res.writeHead(200).end();
});
}).listen(3000);To test it yourself, sign a sample body with the same secret and post it:
BODY='{"schemaVersion":1,"replyId":"r-1","formRevisionId":"rev-1","fields":{}}'
SIG="sha256=$(printf '%s' "$BODY" | openssl dgst -sha256 -hmac "$DASHFORM_WEBHOOK_SECRET" -hex | sed 's/.*= //')"
curl -si -X POST localhost:3000 -H "Content-Type: application/json" \
-H "Idempotency-Key: test-1" -H "X-Dashform-Signature: $SIG" --data-binary "$BODY"A retry schedule, and what your endpoint returns
Your status code is the only thing the sender reads. Return 2xx as soon as the payload is safely stored, and do slow work (posting to Slack, calling the CRM) afterwards from a queue. Stripe's guidance is to return 2xx "before any complex logic that could cause a timeout." Also find out which codes the sender treats as "try again" and which as "give up," so a bug in your handler doesn't turn into silent data loss.
Replay of a failed delivery
Retries cover a blip. If your endpoint was down for an afternoon, you need to resend the failed deliveries yourself, without asking clients to fill in the form again. A replay should carry the same idempotency key, so your dedupe still works.
Schema and revision versioning
Forms change. Someone renames "Budget" to "Budget range" or adds a question, and a field mapping that worked yesterday writes blanks today. Look for three things: a schema version on the payload, answers keyed by a stable key rather than the label, and an identifier for the version of the form the client answered.
Uploaded files and deletion
If your form takes attachments, find out whether the payload carries the file or a link, whether that link needs a login, and whether deleting a submission also deletes its files. If a client asks you to delete their data, you need to know what is left behind.
How Dashform answers the checklist
Checked November 18, 2026 against the Dashform webhook docs and the product source. Anything not listed in the middle column isn't available today.
| Item | Dashform | Not available |
|---|---|---|
| Stable submission ID | replyId in every payload; it never changes | |
| Idempotency key | Idempotency-Key header; automatic retries and manual replays of the same delivery reuse it | |
| Signature | With a signing secret set, X-Dashform-Signature: sha256=<hex>, an HMAC-SHA256 of the raw body | No timestamp in the signature, so rely on the idempotency key to reject repeats |
| Retry schedule | On 408, 429, 5xx, or no response: retries after 1, 5, 15, and 30 minutes, then Failed. A 401 fails without retrying | |
| Replay | Replay on any failed or skipped delivery, with the same key | Replay isn't possible once the reply itself is deleted |
| Delivery log | Per delivery: reply id, state, attempt count, and last error including your status code | A per-attempt history; you see the latest error only |
| Schema version | schemaVersion (currently 1); added fields keep the version, removed or renamed fields get a new one | |
| Form revision | formRevisionId and formId on each payload, plus completedAt | Reading an older revision's questions through the public API; it serves only the live revision |
| Field keys | fields keyed by each question's step key, not its label | |
| Uploaded files | The answer is the file's URL; deleting a reply deletes its uploaded files | Private uploads; anyone with the link can open the file |
| Test path | Point a second Webhook destination at a test endpoint, submit yourself, then delete the test reply | A test or sandbox mode |
| Data export | CSV or JSON export from the Replies tab, and the listReplies API | A retention setting; replies stay until you delete them |
Two more limits to know. Ten failed deliveries in a row pause the integration, and a status other than 2xx, 401, 408, 429, or 5xx pauses it straight away; while paused, new deliveries are held and sent when you switch it back on. And Dashform isn't HIPAA compliant, so don't use it for health information that needs that protection.
On the pricing page (checked November 18, 2026), native integrations, which include the Webhook destination, are listed on the Pro and Business plans. The docs state that export and deletion work the same on every plan.
Receive the webhook in n8n
n8n is a common receiver for small teams because the same workflow can post to Slack, append to a sheet, and create a CRM record. The steps below use n8n's own nodes as documented on docs.n8n.io today.
- Add a Webhook node. Set HTTP Method to POST and turn on the Raw Body option so the exact bytes are kept for verification. Use the test URL while building and the production URL once the workflow is published; they're different.
- Set Respond to "Using 'Respond to Webhook' Node," so you decide when n8n answers.
- Add a Crypto node with the Hmac action, Binary File on, Type SHA256, and Encoding HEX. Put your signing secret in the Crypto credential's Hmac Secret field.
- Add an If node that checks
sha256=plus the computed value equals thex-dashform-signatureheader (n8n lowercases header names). On mismatch, end with a Respond to Webhook node returning 401. The If node does a plain comparison, so for a strict constant-time check, verify in your own endpoint with the snippet above. - Add a Remove Duplicates node with Remove Items Processed in Previous Executions, Keep Items Where "Value Is New," and the
idempotency-keyheader as the value to dedupe on. - Add a Respond to Webhook node with Respond With "No Data" and a 200 Response Code, placed before the slow steps so Dashform gets its answer quickly.
- If the parsed body isn't in the node output with Raw Body on, add an Extract From File node with Extract From JSON on the
databinary field. Then mapfieldsby step key into Slack, Google Sheets, or your CRM.
Field names in n8n's output can differ between versions, so open each node's output in the editor once with a real test submission before you publish the workflow.
Wire it up in Dashform
Add the destination from the form's Connect tab: choose Webhook, enter your HTTPS endpoint, and set a signing secret. Leave Body format on the JSON envelope unless your receiver needs a different shape; a custom template can use tokens such as {{reply_id}} and {{form_revision_id}}. Submit the form yourself, open View Delivery log to confirm the delivery shows as Delivered, then delete the test reply.
If you only need a message in a channel or a row in a sheet, the native Slack and Google Sheets destinations do that without an endpoint to run.
For the questions worth asking on the form before any of this fires, see our project discovery form. For what happens to an inquiry after it lands, the agency client intake process is the nearest guide.







