What is a Slack incoming webhook?

You POST a JSON body to https://hooks.slack.com/services/T.../B.../<secret>. Slack posts the body, rendered as a message, to the channel that URL was bound to at creation. That's the whole interface — no auth header, no API token, no SDK required.

That simplicity is the reason it's the standard transport for form notifications, monitoring alerts, CI status messages, deploy notifications, and anything else that just needs to say something in a channel.

• Post a plain text message. Body: { "text": "hello" }. Slack's mrkdwn renders inside the text field.
• Post a Block Kit message. Body: { "text": "fallback", "blocks": [...] }. Use the Block Kit Payload Generator to build the blocks array interactively.
• Mention users, groups, and channels. <@U123> for a user, <!subteam^S123> for a group, <!here> / <!channel> for broadcast pings.
• Use markdown formatting. *bold*, _italic_, `code`, line breaks. Renders inside any section block with type: “mrkdwn”.
• Include action buttons. Block Kit's actions block. Each button has a label and a URL (or a Slack interaction payload for full Slack-app flows).

• Post to a different channel than the URL is bound to. The channel field exists for backwards compat but new-style Slack-app webhooks ignore it. One webhook = one channel.
• Edit, delete, or reply in a thread. Use the Web API (chat.update, chat.delete, chat.postMessage with thread_ts) and a bot token.
• Send ephemeral or scheduled messages. Web API only — chat.postEphemeral and chat.scheduleMessage.
• Read anything from Slack. Webhooks are write-only. Reading channels, users, or message history needs the Web API and the right scopes.
• Authenticate beyond the URL secret. The secret in the URL is the entire auth — no per-request HMAC, no signed payloads. Treat the URL like a password.

For form notifications you almost never need any of these. If you do, you've outgrown incoming webhooks — create a Slack app with bot scopes and use the Web API.

The minimum valid body:

{
  "text": "hello"
}

A realistic form-notification body:

{
  "text": "New form response from Priya Mehta",
  "blocks": [
    { "type": "header", "text": { "type": "plain_text", "text": "New form response" } },
    { "type": "section", "text": { "type": "mrkdwn",
      "text": "*From:* Priya Mehta\n*Email:* priya@acme.com\n*Budget:* $50,000" } },
    { "type": "context", "elements": [
      { "type": "mrkdwn", "text": "Submitted just now · #leads" }
    ]}
  ]
}

Always include text as a fallback even when you use blocks — Slack uses it for push notifications and accessibility surfaces.

• 200 / “ok” — accepted. The message will appear in the channel.
• 400 / invalid_payload — your JSON is malformed or missing a required field. Most often: missing Content-Type: application/json header.
• 400 / invalid_blocks— JSON parsed but Slack couldn't render the blocks. A block type Slack doesn't recognise, a field exceeding the cap (text limits, fields-per-section caps), or wrong nesting.
• 403 / invalid_token— the URL's secret no longer matches. Regenerate.
• 404 / no_service / no_team — the URL was deleted or never existed. Regenerate.
• 429 — you're sending too fast. Respect the Retry-After header.
• 5xx — Slack-side issue. Retry with exponential backoff.

The Slack Webhook Tester decodes these into one-line plain-English explanations so you don't have to remember the vocabulary.

A Google Form doesn't natively call webhooks. The standard pipeline is:

• onFormSubmit Apps Script trigger fires on every submission, hands your code an event object with the response.
• Your code builds a JSON body (text + blocks) from the response fields.
• UrlFetchApp.fetch POSTs the body to the Slack incoming webhook URL.
• Slack renders the message in the bound channel.

Skip writing this code: the Google Forms to Slack Generator emits the entire Apps Script, paste-ready. The On Submit Trigger Generator covers the broader trigger-installation flow if you want to pick the output yourself.