Form Backend Integrations: Slack, Google Sheets, Zapier, and What They Actually Cost to Set Up

Six integrations sit in the same list on a form's settings page, and reading them as six equally different things is the wrong mental model. Underneath, there are really only two kinds — three that need nothing but a URL, and three that need real setup — and knowing which is which changes how long any of this actually takes to connect. None of them replace each other, either: every enabled integration on a form runs on every submission, independently of the others and of the email alert and dashboard that already exist regardless of which integrations are turned on.

Photo by D koi on Unsplash

The six, side by side

Integration	What you configure	Setup effort	What actually happens on submit
Slack	One Incoming Webhook URL	Paste a URL from a Slack app's settings	A formatted message card posts to the channel
Telegram	Bot Token + Chat ID	Create a bot via @BotFather, find the chat ID	A Markdown message arrives in the bot's chat
Zapier	One "Catch Hook" webhook URL	Paste a URL from a Zap's trigger step	A JSON payload lands in the Zap to route onward
Make	One Custom Webhook URL	Paste a URL from a scenario's webhook module	The same JSON payload lands in the scenario
Webhook (generic)	Any URL, plus an optional secret	Paste a URL you control	The same JSON payload, POSTed with an optional signed header
Google Sheets	Spreadsheet ID, sheet name, service account email, private key	Create a Google Cloud service account and share the sheet with it	A new row is appended to the sheet

Three of these are the same integration

Zapier, Make, and the generic Webhook option aren't three separately built integrations — they run through the exact same code path on submission, POSTing the same JSON body (formId, formName, submittedAt, and a data object of every field) to whichever URL was configured. The only thing that changes between them is what's sitting on the other end of that URL: a Zap's "Catch Hook" trigger, a Make scenario's Custom Webhook module, or a plain endpoint written by hand. Choosing "Zapier" over "Webhook" in the list doesn't unlock anything Zapier-specific — it's the same request either way, just aimed at whichever platform's webhook URL was pasted in. That's worth knowing before assuming Zapier support means some deeper native connection: it means exactly as much integration as pasting one URL requires, no more.

The generic Webhook option is the one meant for a URL someone actually controls, and it carries one thing Zapier and Make don't: an optional secret, sent as an X-NBForms-Secret header on every request. Zapier's and Make's own webhook triggers have no field for checking that header, so it's specifically there for a hand-written receiving endpoint to confirm a request genuinely came from NBForms before trusting its body — the same role an API key plays anywhere else, just carried in a header instead of a query string. Picking Webhook over Zapier or Make isn't about capability; it's about whether the other end is a no-code automation tool or code that can check a header.

Slack and Telegram: also one URL, formatted differently

Slack and Telegram aren't wrapped around a shared generic path the way the three above are, but they're just as lightweight to connect — each needs exactly the credentials in the table above and nothing else. The difference between them and the webhook trio is entirely in the payload shape: Slack gets a proper Block Kit message (a header line, each field laid out, a context footer with the form ID and timestamp), and Telegram gets a Markdown-formatted message through its Bot API, rather than a raw JSON body meant for a script to parse. Both are built to be read by a person the moment they land, not processed by code.

Google Sheets is the one with real setup work

This is the outlier in the table, and it's worth being upfront about why: appending a row to a spreadsheet isn't a webhook call, it's an authenticated write to Google's Sheets API, which means a service account has to exist before any of it works. Concretely: a Google Cloud project, the Sheets API enabled on it, a service account created inside that project, a private key generated for it, and the target spreadsheet explicitly shared with that service account's email address with Editor access. Every other integration in the table is a single field to paste; this one is a small detour through Google Cloud's console first. Once it's done, though, the ongoing behavior is simple — every submission becomes one new row, with field values in the order they arrived, appended to whichever sheet tab is named in the configuration. That last detail matters if a field gets added to the form later: the new value shows up as an extra column in that row rather than slotting into any particular existing column by name, since nothing here maps a field to a specific spreadsheet column on purpose — it just appends what arrived, in order.

What happens when several are enabled at once

Nothing about enabling one integration limits or orders any other. Every enabled integration on a form fires independently on each submission — Slack, Telegram, Sheets, and a Zapier hook can all be active on the same form simultaneously, and a failure in any one of them (an expired token, a revoked webhook URL) is caught and logged without blocking the others. A submission that successfully alerts Slack but fails to reach a stale Zapier URL still shows up in the dashboard, still triggers the email alert, and still succeeds from the submitter's point of view — an integration failing is invisible to whoever filled in the form. The practical upside is that enabling a fifth or sixth integration on a form carries no added risk to the ones already working: each is its own independent attempt, not a chain where an earlier failure stops a later one from running.

What it costs

None of the six are available on the free plan — connecting any integration, from the simplest webhook to Google Sheets, requires the credits tier. Building and testing a form, including its fields and styling, stays free either way; it's specifically the moment a submission needs to reach somewhere beyond NBForms' own dashboard and email alert that the credits tier applies. See pricing for what else that tier includes.

For the mechanics of what happens to a submission before any integration ever sees it — spam filtering, storage, the email alert — see how server-side spam filtering works.