Discord webhooks are a convenient way to send messages automatically from external apps, games, or your own scripts into a channel. However, you may have noticed that when you send more than 30 messages in quick succession, Discord starts rejecting some of them. This is not a bug or a random restriction. It is a deliberate rate limit enforced by Discord to protect its servers and maintain a fair experience for all users.
The core reason for this limit is server load management. Without rate limits, a single misconfigured webhook or a runaway script could flood a channel with thousands of messages per second. That would degrade performance for everyone in that server and could even crash Discord’s backend infrastructure. The 30-message-per-minute cap per channel per webhook is a safety valve that prevents abuse while still allowing legitimate high-frequency notifications.
This article explains exactly why the 30-per-minute limit exists, how Discord’s rate limiting system works under the hood, and what you can do to work within or around this restriction using proper techniques.
Key Takeaways: Discord Webhook Rate Limits Explained
- Rate limit header X-RateLimit-Remaining: Shows how many more requests you can send before being blocked for that window.
- Retry-After header: Tells your script exactly how many seconds to wait before sending the next request.
- Webhook queue with backoff: Instead of sending 30 messages instantly, space them out by at least 2 seconds each to stay under the limit.
How Discord Rate Limits Work for Webhooks
Discord uses a sliding window algorithm to track how many requests a webhook has made in the last 60 seconds. The window is not a fixed clock minute. It slides forward with every request. For example, if you send a message at 0 seconds, then another at 55 seconds, both count toward the same window. The oldest request falls out of the window after 60 seconds have passed since it was made.
The limit is 30 requests per webhook per channel. This means each webhook has its own counter. If you have two different webhooks in the same channel, each can send up to 30 messages per minute. The limit is not per user or per bot. It is per webhook URL.
When you exceed the limit, Discord returns HTTP status code 429 with a JSON body containing a retry_after field in milliseconds. Your client must wait that exact duration before sending another request. Ignoring this and retrying immediately will only extend the ban or get your webhook temporarily disabled.
Why Not a Higher Limit?
Discord’s infrastructure handles millions of concurrent connections. A single server can have hundreds of webhooks. If each webhook could send 100 messages per minute, a single misconfigured integration could generate 10,000 messages per minute for one channel. That would overwhelm the gateway, increase latency for voice and text, and consume excessive storage. The 30-per-minute limit is a balance between utility and stability.
Rate Limit Headers You Must Read
Every response from Discord’s webhook API includes these headers:
X-RateLimit-Limit— Always 30 for webhooksX-RateLimit-Remaining— How many requests left in the current windowX-RateLimit-Reset— Unix timestamp when the window resetsX-RateLimit-Reset-After— Milliseconds until the window resetsRetry-After— Seconds to wait when you hit the limit
Your script must parse these headers and delay accordingly. Do not hardcode a 2-second delay. Use the Retry-After value from the 429 response.
Working Within the 30-Message Limit
The most reliable way to stay under the limit is to queue your messages and send them at a controlled rate. If you need to send 60 messages, do not fire them all at once. Instead, send one every 2 seconds. That keeps you at 30 per minute without hitting the 429 response.
- Calculate your send interval
Divide 60 seconds by your target messages per minute. For 30 messages, 60 / 30 = 2 seconds between sends. For 20 messages, 60 / 20 = 3 seconds. - Implement a queue with a timer
In your code, push messages into a queue. A separate loop pops one message every N seconds and calls the webhook. If you receive a 429, read theRetry-Aftervalue and pause the timer by that amount. - Use a library with built-in rate limiting
Many Discord API wrappers like discord.js (for Node.js) or discord.py (for Python) handle rate limits automatically. They queue requests and respectRetry-After. Use them instead of raw HTTP calls. - Batch messages into embeds
Each webhook call can contain up to 10 embeds. Instead of sending 10 separate messages with one embed each, send one message with 10 embeds. This reduces the number of API calls. - Use multiple webhooks for parallel channels
If you need to send more than 30 messages per minute total, create separate webhooks for different channels. Each webhook has its own 30-per-minute limit. Distribute your messages across channels.
Common Mistakes That Trigger the Rate Limit
“I sent 30 messages in 30 seconds and got blocked”
The sliding window counts the last 60 seconds. Sending 30 messages in the first 30 seconds, then another 10 in the next 30 seconds will exceed the limit because the first messages are still in the window. You must wait 60 seconds from the first message before the count resets.
“I waited 60 seconds but still get 429”
The Retry-After header may indicate a longer wait if Discord’s internal state is still cleaning up. Always use the Retry-After value from the 429 response, not a fixed 60-second sleep.
“My bot sends messages faster than the webhook”
Bot accounts have different rate limits than webhooks. A bot can send up to 5 messages per second per channel, but webhooks are capped at 30 per minute. Do not assume the same speed applies.
“I use multiple webhooks in one channel but still get limited”
Each webhook has its own counter. If you have 3 webhooks in the same channel, each can send 30 messages per minute. That gives you a total of 90 messages per minute for that channel. Verify that each webhook is a separate URL.
Webhook Limits: Single Webhook vs Multiple Webhooks
| Item | Single Webhook | Multiple Webhooks (3 in one channel) |
|---|---|---|
| Messages per minute | 30 | 90 |
| Rate limit scope | Per webhook URL | Per webhook URL, independent counters |
| Implementation complexity | Low — one queue | Medium — must distribute messages across URLs |
| Risk of hitting limit | High if sending bursts | Lower if balanced correctly |
| Recommended for | Low-frequency alerts | High-frequency logs or notifications |
Using multiple webhooks is the only way to increase throughput per channel without violating rate limits. Each webhook URL must be created separately in Server Settings > Integrations > Webhooks.
The 30-message-per-minute limit per webhook is a necessary constraint to keep Discord stable and responsive for all users. By understanding the sliding window algorithm and respecting the Retry-After header, you can send messages reliably without hitting errors. If you need higher throughput, use multiple webhooks in different channels or batch content into embeds. Always test your integration with a small burst before deploying to production. Monitor the X-RateLimit-Remaining header in your logs to catch approaching limit issues early.