Telegram Bot API Limits: Rate Limits, 429 Errors, File Sizes and Message Length

Updated: October 29, 2026 · 6 min read

Telegram Bot API rate limits look simple on paper: about 1 message per second in a single chat, 20 messages per minute in a group, and roughly 30 messages per second across all chats. Exceed them and the API answers 429 Too Many Requests with a retry_after value. This page collects the Telegram Bot API limits in one place (sending rates, paid broadcasts, file sizes, text lengths and updates) with code that keeps your bot inside them.

Telegram Bot API rate limits for sending messages

The official Bots FAQ lists these limits for regular, free sending:

Treat these numbers as guidelines rather than a contract. Telegram notes that limits may change, and flood limits are not raised in the test environment (they can even be stricter there). Code that respects retry_after survives changes that would break a hardcoded "30".

429 Too Many Requests and retry_after

When you hit a flood limit, the response looks like this:

{
  "ok": false,
  "error_code": 429,
  "description": "Too Many Requests: retry after 17",
  "parameters": {"retry_after": 17}
}

retry_after is the number of seconds left before the request can be repeated. Wait at least that long, then send the same request again; immediate retries only prolong the block. A Python helper:

import time
import requests

API = "https://api.telegram.org/bot123456789:AAEexampleTokenReplaceWithYours"

def call(method, max_attempts=5, **params):
    for _ in range(max_attempts):
        r = requests.post(f"{API}/{method}", json=params, timeout=30).json()
        if r["ok"]:
            return r["result"]
        if r["error_code"] != 429:
            raise RuntimeError(f'{r["error_code"]}: {r["description"]}')
        time.sleep(r.get("parameters", {}).get("retry_after", 1) + 0.5)
    raise RuntimeError("still rate limited, giving up")

call("sendMessage", chat_id=123456789, text="Hello")

The same logic in JavaScript:

const API = "https://api.telegram.org/bot123456789:AAEexampleTokenReplaceWithYours";
const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

async function call(method, params, maxAttempts = 5) {
  for (let i = 0; i < maxAttempts; i++) {
    const res = await fetch(`${API}/${method}`, {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify(params),
    });
    const data = await res.json();
    if (data.ok) return data.result;
    if (data.error_code !== 429) throw new Error(data.description);
    await sleep(((data.parameters?.retry_after ?? 1) + 0.5) * 1000);
  }
  throw new Error("still rate limited");
}

Throttle broadcasts with a queue

Retries fix single requests. For newsletters and notifications you have to pace the sending itself, for example at a global rate a little below 30 messages per second:

def broadcast(chat_ids, text, per_second=25):
    for chat_id in chat_ids:
        try:
            call("sendMessage", chat_id=chat_id, text=text)
        except RuntimeError as e:
            print(chat_id, e)  # 403: the user blocked the bot, drop them
        time.sleep(1 / per_second)

In production, run this in a background worker, keep a per-chat timestamp so no chat gets more than one message per second, and drop chats that return 403 instead of retrying them. Without paid broadcasts, Telegram recommends spreading large mailings over longer intervals, such as 8–12 hours.

Paid broadcasts: up to 1000 messages per second

If 30 messages per second is not enough, enable paid broadcasts in @BotFather and pass "allow_paid_broadcast": true to send methods such as sendMessage, sendPhoto or sendMediaGroup. The bot can then broadcast up to 1000 messages per second. Every message above the free 30 per second costs 0.1 Telegram Stars from the bot's balance, and only successfully broadcast messages are charged. Eligibility requires a minimum Stars balance (the Bots FAQ also mentions an audience threshold), so check the official docs for the current numbers before you plan around it.

Telegram bot file size limits

A local Bot API server lifts the two biggest restrictions: uploads up to 2000 MB and downloads without a size limit, plus webhooks over plain HTTP on any port. Call logOut before you point the bot at your own server. To check a file before downloading, call getFile in the Bot API Tester and look at file_size and file_path.

Message length and other content limits

callback_data is counted in bytes, and characters outside ASCII take 2–4 bytes each in UTF-8, so store a short id in the button and keep the details in your database. Texts longer than 4096 characters must be split, preferably on line breaks:

def split_text(text, limit=4000):  # a little below 4096 to be safe
    parts, current = [], ""
    for line in text.splitlines(keepends=True):
        if current and len(current) + len(line) > limit:
            parts.append(current)
            current = ""
        while len(line) > limit:
            parts.append(line[:limit])
            line = line[limit:]
        current += line
    if current:
        parts.append(current)
    return parts

Updates and webhook limits

• Incoming updates are kept on Telegram's servers for up to 24 hours until your bot receives them.
• getUpdates returns 1–100 updates per call (limit, default 100). Use timeout for long polling and confirm updates with offset = last update_id + 1.
• getUpdates doesn't work while a webhook is set (409 Conflict) until you call deleteWebhook.
• setWebhook accepts max_connections 1–100 (default 40) and ports 443, 80, 88 and 8443 only. A local Bot API server allows up to 100000 connections and any port.

How to stay under Telegram Bot API limits

• Send everything through one queue with a global rate below 30 per second and at most one message per second per chat.
• Show progress by editing one message with editMessageText instead of posting many new ones.
• Resend media by file_id rather than uploading it again.
• Honor retry_after, and never retry 403 errors.
• Pass allowed_updates so you receive only the update types you actually handle.

Related guides: sending messages with the Bot API covers formatting and per-message errors, setting up a webhook explains receiving updates at scale, and what's new in Bot API 10 introduces rich messages and their limits.