Skip to content
HookDeploy

Slack webhooks

Last verified against Slack's documentation on September 27, 2026.

On this page ↓

Slack sends webhooks to your app when something happens in a workspace: a message is posted, someone mentions your bot, a user joins a channel, a button is clicked. Slack is strict about how your server responds. You get 3 seconds, a URL verification challenge before any events arrive, and a signature that expires after 5 minutes. When too many deliveries fail, Slack turns your event subscriptions off. This page covers what Slack sends, how it delivers, how to fix the common errors, and where HookDeploy fits.

Looking to send messages into Slack instead? That’s incoming webhooks, covered in the FAQ.

What Slack sends webhooks for

Slack sends three kinds of HTTP requests to your app, each configured separately in your app’s settings.

KindWhat triggers itExamples
Events APIActivity in a workspace your app is installed inmessage.channels, app_mention, reaction_added, member_joined_channel, team_join, app_home_opened, app_uninstalled
Slash commandsA user runs your command, such as /deployForm-encoded payload with the command, text, user, channel, and a response_url
InteractivityA user clicks a button, submits a modal, or picks a menu optionForm-encoded payload field with the action details and, for most interactions, a response_url

Events API requests are JSON. Most events arrive wrapped in an event_callback envelope with an event_id, event_time, team_id, and the event itself under event. The first request to a new Request URL is a url_verification challenge instead.

Subscribe only to the events you handle. Slack caps event deliveries at 30,000 per workspace per app per hour, and extra subscriptions eat into that.

How Slack delivers webhooks

BehaviorDetail
Signature headerX-Slack-Signature, formatted v0=<hex>: an HMAC-SHA256 of v0:{timestamp}:{raw body}, keyed with your app’s signing secret
Timestamp headerX-Slack-Request-Timestamp, part of the signed string
Timestamp toleranceSlack’s guidance and SDKs reject requests more than 5 minutes old
URL verificationA new Request URL receives a url_verification request and must respond with its challenge value
Timeout3 seconds for a 2xx response
Events API retriesUp to 3: nearly immediately, after 1 minute, and after 5 minutes, with x-slack-retry-num and x-slack-retry-reason headers
Opting out of retriesRespond with the header X-Slack-No-Retry: 1
RedirectsMore than 2 redirects counts as a failure
DisablingIf more than 95% of deliveries fail within 60 minutes, event subscriptions are temporarily disabled and the app owner gets an email
Rate limit30,000 events per workspace per app per hour. Beyond that, Slack sends an app_rate_limited event instead
Slash commands and interactivity3 seconds to acknowledge, or the user sees an error. Reply later through response_url for up to 30 minutes
Secret rotationAfter you regenerate the signing secret, the previous one stays valid for 24 hours

Common Slack webhook errors and how to fix them

“Your URL didn’t respond with the value of the challenge parameter”

When you enter a Request URL under Event Subscriptions, Slack sends a url_verification request and expects the challenge value back. A server that isn’t running yet, rejects the request, or returns the wrong body fails the check, and Slack won’t save the URL. Your endpoint must answer this request before any other logic runs, including before checking for an event_callback type.

http_timeout retries

Slack waited more than 3 seconds, marked the delivery failed, and retried it with x-slack-retry-reason: http_timeout. The usual culprit is a handler that calls the Slack Web API, a database, or an LLM before responding. Verify the signature, return 200, and do the work from a queue.

Duplicate events

Retries resend the same event, so a slow handler that finished its work but responded late will see that event again. Deduplicate on the envelope’s event_id, not on the retry headers. If a retry is useless to you, respond with X-Slack-No-Retry: 1.

Signature verification fails

  • The body was parsed first. Slack signs the exact raw bytes. Slash commands and interactivity are form-encoded, so a URL-encoded body parser breaks verification just as a JSON parser does.
  • Wrong base string. The signed string is v0:{timestamp}:{body}. Hashing only the body will never match.
  • Wrong secret. Use the Signing Secret from Basic Information, not the bot token or the deprecated verification token. After regenerating it, the old secret keeps working for 24 hours.
  • Clock drift. A server clock off by more than 5 minutes rejects valid requests. Sync with NTP.

“operation_timeout” on slash commands

The user ran your command and Slack didn’t get an acknowledgment within 3 seconds. Acknowledge with an empty 200 immediately, then post the actual result to the response_url from the payload.

Event subscriptions disabled

More than 95% of deliveries failed within an hour, so Slack switched off your event subscriptions and emailed the app owner. Fix the cause, then re-enable events in your app’s settings. Events that occurred while subscriptions were off aren’t sent afterward, so backfill what you need through the Web API.

app_rate_limited events

Your app went past 30,000 events per workspace in an hour. Slack drops the excess rather than queueing it. Trim your subscriptions, and use the Web API to fill any gaps.

Why use HookDeploy with Slack

URL verification is handled for you

HookDeploy’s Slack platform verification preset answers the url_verification challenge at the edge, so you can register your Request URL before your handler even exists. Challenge requests aren’t stored and don’t count toward your usage. The preset is available on Starter and above.

Every event acknowledged inside 3 seconds

HookDeploy captures each Events API delivery at Cloudflare’s edge and responds to Slack well inside its 3-second limit, before forwarding it to your server. A slow handler, a deploy, or an outage on your side stops producing Slack retries and duplicates, and stops pushing you toward the 95% failure threshold that disables your subscriptions. From there:

  • Destination retries. Starter retries 3 times (after 30 seconds, 5 minutes, and 30 minutes). Pro and Scale retry up to 5 times on a schedule you choose. Free doesn’t retry automatically.
  • Incidents. Forward failures are grouped into incidents, and you can bulk-replay them at a controlled rate once your server recovers.
  • History. Slack has no event log you can replay from. HookDeploy keeps every captured event for your plan’s retention period, from 7 days on Free to 365 days on Enterprise.

Signatures arrive intact

On first delivery, HookDeploy forwards Slack’s original body with X-Slack-Signature and X-Slack-Request-Timestamp unchanged. Both headers are on HookDeploy’s protected list: they’re never redacted from stored requests, and custom header strip rules can’t remove them. Your handler verifies exactly as if Slack had called it directly.

One app, many destinations

Send each Slack event to your bot, an analytics pipeline, and an audit log in parallel. A failing destination doesn’t hold up the others. Free includes 1 destination per endpoint, Starter includes 5, and Pro and above are unlimited.

Run your bot where Slack can’t reach it

Slack needs a public HTTPS Request URL. With HookDeploy, that URL belongs to HookDeploy, and the HookDeploy Agent connects outward from your network over mTLS to deliver events to a local port. Internal bots can stay on private infrastructure with no public IP or open port.

Develop against live workspace events

A tap sends a temporary copy of live events from a development workspace to 127.0.0.1 on your machine. You can also replay any captured event to your local handler, which is much faster than posting a new message every time you want a fresh message.channels event.

Know the limits

  • Slash commands and interactivity. HookDeploy responds to Slack before your app sees the request, so your app can’t put anything in that response. That rules out immediate slash command replies, response_action errors on modal submissions, and loading options for external select menus. If your app only needs to acknowledge and then reply through response_url, set a custom response of 200 with an empty body. Otherwise, point those request URLs directly at your app.
  • The 5-minute signature window. HookDeploy’s first retry, 30 seconds after a failure, lands inside it. Later retries and most replays don’t. See Verifying late deliveries.
  • Plan limits. A busy workspace can send a lot of events. On Free, requests beyond the monthly allowance or the daily limit get a 429, which Slack counts as a failure toward the 95% threshold. Paid plans keep accepting traffic past the included volume.
  • Transformations and privacy filters. A transformation changes the body, and a privacy filter changes the stored copy used for retries and replays. Either way, Slack’s signature won’t match at that destination.

Verifying late deliveries and replays

A retry or replay re-sends Slack’s original body, signature, and timestamp. If it arrives more than 5 minutes after Slack signed it, the standard check rejects it, even though the signature is genuine. Unlike some providers, Slack has no API to fetch an event by its ID, so you can’t ask Slack to confirm it.

If you want late deliveries processed, one sound approach is:

  1. Verify the signature’s HMAC as usual. That still proves Slack authored the request.
  2. Skip only the 5-minute age check, and only for requests that carry HookDeploy’s x-hookdeploy-forward header and an auth header you inject on that destination. Anything arriving another way still gets the full check.
  3. Deduplicate on event_id, so the same event can never be processed twice.

Together, those three checks give you what the age check was protecting: proof that Slack sent it, proof it came through your own HookDeploy endpoint, and protection against processing it twice. If late events aren’t useful to you, for example because a bot shouldn’t reply to a 20-minute-old message, keep the standard check and let them fail.

Set up Slack with HookDeploy

  1. In HookDeploy, create an endpoint (for example, Slack events) and copy its URL.
  2. On the endpoint, open the Security tab, then Verification, and choose Slack as the platform preset.
  3. In your app’s settings at api.slack.com, open Event Subscriptions and turn on Enable Events.
  4. Paste your HookDeploy URL as the Request URL. HookDeploy answers the challenge, and Slack marks the URL as verified.
  5. Under Subscribe to bot events, add the events you handle, and save. Reinstall the app if Slack asks you to.
  6. In HookDeploy, add a forward destination pointing to your handler, or to an agent for private delivery, and set its retries.
  7. Mention your bot or post in a channel it’s in, and confirm the event appears in HookDeploy and reaches your handler.

Example handler (Node.js and Express)

import crypto from 'node:crypto';
import express from 'express';

const app = express();

// Raw body parser on this route, registered before any global body parsing.
app.post('/webhooks/slack', express.raw({ type: '*/*' }), async (req, res) => {
  const timestamp = req.get('x-slack-request-timestamp') ?? '';
  const signature = req.get('x-slack-signature') ?? '';

  // Reject requests older than 5 minutes (replay protection).
  if (Math.abs(Date.now() / 1000 - Number(timestamp)) > 60 * 5) {
    return res.status(401).send('Stale request');
  }

  const expected = 'v0=' + crypto
    .createHmac('sha256', process.env.SLACK_SIGNING_SECRET)
    .update(`v0:${timestamp}:${req.body.toString('utf8')}`)
    .digest('hex');

  const valid =
    signature.length === expected.length &&
    crypto.timingSafeEqual(Buffer.from(signature), Buffer.from(expected));
  if (!valid) return res.status(401).send('Invalid signature');

  res.sendStatus(200);  // respond well inside Slack's 3 seconds
  const body = JSON.parse(req.body.toString('utf8'));
  await enqueue({ eventId: body.event_id, event: body.event });  // skip event IDs you've already handled
});

FAQ

Does HookDeploy handle Slack's URL verification challenge?

Yes. Turn on the Slack platform verification preset on your endpoint, available on Starter and above, and HookDeploy answers Slack's url_verification request with the challenge value itself. Verification requests aren't stored and don't count toward your usage.

Can I route slash commands and interactive components through HookDeploy?

Only when a bare acknowledgment is enough. HookDeploy responds to Slack before your app sees the request, so your app can't return a message, modal validation errors, or menu options in that response. Configure a custom response of 200 with an empty body and reply later through the payload's response_url. Anything that needs a real synchronous response should point directly at your app.

Does HookDeploy break Slack signature verification?

Not on first delivery. HookDeploy forwards Slack's original body, X-Slack-Signature, and X-Slack-Request-Timestamp unchanged. Slack's signature includes a timestamp, and the standard check rejects anything more than 5 minutes old, so late retries and replays need the approach described under Verifying late deliveries.

Will HookDeploy stop Slack from disabling my event subscriptions?

Yes, as long as HookDeploy captures the delivery. Slack disables subscriptions when more than 95% of deliveries fail within 60 minutes, and HookDeploy responds within Slack's 3 seconds even when your server is down. Requests HookDeploy rejects before capture, such as those over a Free plan's limits, still count as failures.

I want to send messages to Slack, not receive events. Is this the right page?

Sending messages to Slack uses incoming webhooks, which are URLs you post to. HookDeploy can forward any webhook to a Slack incoming webhook URL as a destination, and its Slack integration can alert a channel when deliveries succeed or fail.

Should I use Socket Mode instead?

Socket Mode lets your app receive events over a WebSocket it opens to Slack, so you don't need a public URL. It suits apps that run as one long-lived process. HookDeploy suits HTTP-based apps that want every event captured, inspectable, and replayable, fanned out to several destinations, or delivered to a server with no public URL.

Capture Slack webhooks free

Start free