Kalshi API Rate Limits: Token Buckets by Tier Explained
Reference

Kalshi API Rate Limits: Token Buckets by Tier Explained

· EdgeOutcome Team· kalshi, api, rate-limits
Last updated

Most Kalshi API guides, including ours until recently, repeat a flat number: 100 requests per second, or 100 requests per 10 minutes, depending on which blog post you landed on. Both are wrong. Kalshi meters tokens, not requests. Every authenticated call costs tokens, your tier sets a per-second token refill rate, and your real capacity for an endpoint is budget divided by cost.

That distinction changes how you write a bot. A Basic account gets 20 market reads per second but only 10 order writes per second, and the balance endpoint has a bucket of its own that is far tighter than the read budget. A 25-order batch can be rejected even when you are nowhere near your usual rate, because the whole batch has to fit in the bucket at once.

Every number below was checked on November 2, 2026 against the official rate limit documentation and the live API on api.elections.kalshi.com.

Key Takeaway: Kalshi rate limits are token buckets. Default request cost is 10 tokens, so sustained rate = tier budget / cost. Basic allows 20 reads or 10 orders per second; write buckets above Basic can burst three seconds’ worth at once. There are no rate limit headers, a 429 body is {"error": "too many requests"}, and there is no penalty, so correct backoff is a short sleep, not a long one.

The read and write buckets are separate

You have two independent token budgets, and the split is by operation type, not by protocol:

  • Read: GET endpoints and anything not routed to Write
  • Write: order placement, amends, cancels, order groups, the RFQ quote flow, and block trade proposal accepts

REST and FIX requests drain the same buckets, so switching protocols does not buy you headroom. The GET /portfolio/balance endpoint is metered in a third bucket of its own and does not touch the read budget: Basic and Advanced can call it once per second, every higher tier five times per second, and that bucket holds only one second of budget, so there is no burst. Balance changes on fills, settlements and transfers, which means the honest replacement for balance polling is the user-fills WebSocket channel covered in the Kalshi WebSocket guide.

Predictions traffic also splits by exchange shard. An order write that names a shard (exchange_index of 1 or higher) draws from that shard’s write bucket, each of which carries your full tier budget. Shard 0 bills your unscoped write bucket, and auto-routed traffic, meaning exchange_index: -1 or no index at all with a market_ticker, is billed to every shard’s write bucket. Batches always bill unscoped. Read budgets are never shard-scoped.

Kalshi API rate limits by tier

Predictions (event contract) budgets, in tokens per second:

TierRead budgetWrite budgetReads/sOrders/s
Basic2001002010
Advanced3003003030
Expert6006006060
Premier1,2001,200120120
Paragon2,4002,400240240
Prime4,8004,800480480
Prestige12,0009,6001,200960

Perps are metered in their own buckets, so perps calls never eat your event-contract budget:

TierPerps readPerps writePerps read/sPerps orders/s
Basic4002004020
Advanced6006006060
Expert6001,20060120
Premier1,0003,000100300
Paragon2,0006,000200600
Prime4,00012,0004001,200
Prestige6,00024,0006002,400

Note the asymmetry at Expert and above: perps write budgets run well ahead of event-contract write budgets. Single-order perps cancels and decreases, and FIX order cancel requests, cost 1 token instead of 10, which makes cancel-heavy perps strategies far cheaper than they look.

Basic comes with account signup. Advanced needs one call to the upgrade endpoint, which costs 30 tokens rather than the default 10. Expert and above are granted by volume or assigned manually.

A 500-market sweep has a hard time floor

The budgets translate into a minimum wall-clock time that no amount of async code can beat. One market read costs 10 tokens, so 500 markets cost 5,000 tokens:

  • Basic: 5,000 / 200 = 25 seconds minimum per full sweep
  • Advanced: about 16.7 seconds
  • Premier: about 4.2 seconds

That is the number to design around. A scanner that polls 500 markets every 5 seconds works on Prime and fails on Basic, no matter how many worker threads it spawns. In practice you avoid most of the cost: filter with mve_filter=exclude, query one series_ticker at a time, and page with limit=1000 instead of calling per market, as covered in the open interest and order book guide.

Some endpoints cost more than the default, and the authoritative list is public. GET /trade-api/v2/account/endpoint_costs needs no authentication and returned default_cost: 10 plus 20 non-default entries on November 2, 2026, including:

  • GET /trade-api/v2/cfbenchmarks: 50 tokens, five times the default
  • POST /trade-api/v2/account/api_usage_level/upgrade: 30 tokens
  • GET /trade-api/v2/portfolio/orders/{order_id}: 2 tokens
  • RFQ and quote calls: 1 to 30 tokens depending on the operation

A 50-token call is 25 percent of the entire Basic read budget for one second. Poll a benchmark series once per second on Basic and you have nothing left for anything else.

Bursting: most buckets bank three seconds

Each budget is a token bucket that refills continuously, with no fixed windows and no per-second reset. Capacity is what decides how much you can fire at once:

  • Basic and Advanced read buckets: three seconds of budget
  • Write buckets above Basic: three seconds of budget
  • Read buckets above Advanced, all perps read buckets, and the Basic write bucket: one second of budget

A Premier write bucket refills at 1,200 tokens per second and holds 3,600. Idle for three seconds, then fire 360 orders at once and all of them are accepted. That is exactly the shape an event-driven client wants: quiet all day, then a block of orders the moment the market moves.

At Basic the write bucket tops out at 100 tokens, which is 10 orders total. There is no banking beyond that, which matters for the next section.

Batches do not save tokens, and they can be rejected whole

Batching reduces round trips, not cost. Every item is billed separately:

  • Batch create 25 orders: 25 x 10 = 250 tokens
  • Batch cancel 25 orders: 25 x 2 = 50 tokens

And the rule that catches people: the entire batch must fit in the bucket at the moment it arrives, or the whole batch is rejected. On Basic the write bucket holds 100 tokens, so a 25-order create batch needs 250 tokens it can never have. The same batch is fine on Advanced, where capacity is 900.

If your bot places orders in blocks, either upgrade or split the block into chunks small enough to fit your bucket. A silent rejection here looks like a strategy that stopped trading.

What a 429 actually returns

Update, November 16, 2026: Kalshi’s changelog now announces X-RateLimit-Limit, X-RateLimit-Remaining, X-RateLimit-Reset and X-RateLimit-Cost headers on REST responses (not on cacheable public data, and 429s carry no Retry-After). Details and the other recent API changes are in our Kalshi API changelog tracker.

A throttled request returns HTTP 429 with a single-line body:

{"error": "too many requests"}

No Retry-After, no X-RateLimit-* headers, and none on successful responses either. We checked headers across 150 rapid requests on November 2, 2026 and found no rate limit header of any kind. That matches the older undocumented behaviour writeup and it is still true, so your client cannot learn the remaining budget from the response.

There is no penalty and no cooldown. The bucket refills, and the next request succeeds as soon as the balance covers the cost, which at 1,200 tokens per second is roughly 8 milliseconds for a 10-token order. Backoff should therefore be short and jittered, not minutes long:

import random, time, requests

def request_with_backoff(method, path, headers, max_attempts=6):
    for attempt in range(max_attempts):
        resp = requests.request(method, f"https://api.elections.kalshi.com/trade-api/v2{path}",
                                headers=headers, timeout=10)
        if resp.status_code != 429:
            resp.raise_for_status()
            return resp.json()
        # buckets refill in milliseconds; start at 50ms, cap at ~1.6s
        wait = min(0.05 * (2 ** attempt), 1.6) * (0.5 + random.random())
        time.sleep(wait)
    raise RuntimeError("still rate limited after %d attempts" % max_attempts)

Two rules make retries safe. Order placement is not idempotent by URL, so send the same client_order_id on a retry and Kalshi rejects the duplicate instead of filling twice, as in the Python API tutorial. And back off in your own scheduler rather than relying on a fixed 60-second sleep left over from old guides.

Read your own limits from code

Do not hardcode the tier tables. GET /account/limits returns exactly the numbers your key is currently held to:

{
  "usage_tier": "premier",
  "read":  { "refill_rate": 1200, "bucket_capacity": 1200 },
  "write": { "refill_rate": 1200, "bucket_capacity": 3600 },
  "grants": [
    { "exchange_instance": "event_contract", "level": "premier", "expires_ts": 1751558400, "source": "volume" },
    { "exchange_instance": "event_contract", "level": "advanced", "source": "manual" }
  ]
}

A grant without expires_ts is permanent. Your effective tier is the highest active grant, and a volume grant is renewed for 30 days by a daily review, so the value can drop when a grant lapses.

That response is enough to derive a safe budget for your own loop:

import requests

def budget(headers, base="https://api.elections.kalshi.com/trade-api/v2"):
    lim = requests.get(base + "/account/limits", headers=headers, timeout=10).json()
    read_rps  = lim["read"]["refill_rate"] / 10        # default cost = 10 tokens
    order_rps = lim["write"]["refill_rate"] / 10
    burst_orders = lim["write"]["bucket_capacity"] // 10
    return lim["usage_tier"], read_rps, order_rps, burst_orders

tier, read_rps, order_rps, burst = budget(headers)
print(f"{tier}: {read_rps:.0f} reads/s, {order_rps:.0f} orders/s, max {burst} orders per burst")

Run it at startup, then size threads, batch sizes and sleep intervals from the result instead of from a blog post. The perps counterpart is GET /account/limits/perps; both endpoints need a signed request and return 401 without one. Test the whole loop against the Kalshi demo environment before you let it place a live order.

WebSocket connections have their own cap

Predictions and perps connections share one per-user concurrent connection limit, and hitting it returns 429 on the handshake rather than on a message:

TierConcurrent connections
Basic200
Advanced200
Expert200
Premier500
Paragon750
Prime1,000
Prestige1,000

200 connections is a lot for a single-user bot and not much for a platform serving other people’s keys. If you fan out subscriptions per market instead of per series, you can hit the cap long before you hit any token budget.

How a higher tier is actually earned

Expert and above are granted from trading volume. Once a day Kalshi computes your volume share as your trailing 30-day volume, counting both sides of every trade where you were maker or taker, divided by twice the previous calendar month’s total exchange volume. Each tier has an earn threshold and a lower keep threshold:

TierEarnKeep
Expert0.075%0.05%
Premier0.125%0.10%
Paragon0.25%0.20%
Prime0.50%0.40%
Prestige1.00%0.80%

A qualifying review grants the tier for 30 days and renews on each qualifying daily review. A dip below the keep threshold does not drop you immediately, the tier lapses when the current grant runs out.

Expert insight: Almost every “bot gets blocked by Kalshi” report we see is not a rate limit at all. It is one of three things: an API key signature failure, a batch rejected whole because it did not fit the bucket, or a fixed 60-second sleep copied from a 2025 guide that is now 7,000 times longer than necessary. Check the response body before you blame throttling.

What to do with this

Three changes make a bot rate-limit-proof in an afternoon. Read your limits from GET /account/limits at startup. Give orders a stable client_order_id so retries cannot double-fill. And treat batch size as a budget decision, not a convenience.

If you want the fee and payout maths that go with position sizing, the free cheat sheet and the payout calculator cover it. For a ready-made client that already signs requests, reads its own limits and backs off correctly, the Kalshi bot kit is the packaged version of the code in this post, and you can test it against live markets with a Kalshi account.

EdgeOutcome may earn a commission if you open a Kalshi account through the link above. It does not change what you pay.

18+. Prediction markets involve real financial risk. Availability depends on your country and US state.

Frequently Asked Questions

What are the Kalshi API rate limits?

Kalshi meters authenticated requests in tokens, not request counts. Every request costs tokens and your tier sets a per-second token budget that refills continuously. The default cost is 10 tokens, so sustained capacity is budget divided by cost. Basic is 200 tokens per second on reads and 100 on writes, which works out to 20 reads or 10 orders per second. Prestige is 12,000 read tokens and 9,600 write tokens per second, checked on November 2, 2026.

Does the Kalshi API return rate limit headers?

No. Requests carry no X-RateLimit-* and no Retry-After header, and 429 responses do not add them. A throttled request returns status 429 with the body {"error": "too many requests"}. On November 2, 2026 we checked response headers across 150 rapid requests and found no rate limit header of any kind, so backoff timing has to come from your own state.

Is there a penalty for hitting a Kalshi rate limit?

No. There is no penalty, ban, or cooldown. The bucket keeps refilling and the next request succeeds as soon as the balance covers its cost. At the Premier write budget of 1,200 tokens per second an empty bucket refills enough for a 10-token order in about 8 milliseconds, so a short sleep is usually enough.

Do batch endpoints save tokens on Kalshi?

No, and the batch can be rejected outright. Each item is billed separately: a 25-order create batch costs 25 x 10 = 250 tokens, and a 25-order cancel batch costs 25 x 2 = 50 tokens. The whole batch must fit in the bucket at the moment it arrives. At Basic the write bucket holds only 100 tokens, so a 25-order create batch cannot fit and the entire batch is rejected.

How do I check my own Kalshi rate limits?

Call GET /account/limits with a signed request. It returns usage_tier plus read and write objects with refill_rate and bucket_capacity, and a grants array showing whether each level came from volume or was assigned manually. For perps the counterpart is GET /account/limits/perps. GET /account/endpoint_costs needs no authentication at all and lists every non-default token cost.

EdgeOutcome
EdgeOutcome Team

Data-driven prediction market analysis. EdgeOutcome helps traders find real edges on Kalshi and Polymarket — not hype, just numbers. More about us →