Physical Address
304 North Cardinal St.
Dorchester Center, MA 02124
Physical Address
304 North Cardinal St.
Dorchester Center, MA 02124
A rate limiter caps your requests to a crypto exchange, RPC node, or data API and returns a 429 when you go over. Here is how it works and how to stop getting blocked.
A rate limiter caps how many requests a client can send to a service in a set time window, then rejects or delays anything over that cap. In crypto, that service is usually an exchange, an RPC node, or a data API.
You probably landed here because a bot, a tracker, or a first dApp just threw an HTTP 429. That error is the rate limiter talking. It rarely means your code is broken. Far more often, it means a guardrail is doing its job.
So this guide defines the rate limiter in plain terms, then answers what the generic engineering explainers skip. Why does your exchange bot, RPC node, or data feed keep getting blocked, and how do you stop it? We will cover the mechanism, the algorithms, real 2026 provider limits, and the fixes worth trying in order.
A rate limiter is a gatekeeper that counts your requests and cuts you off once you cross a threshold. Send 20 calls a second when the cap is 10, and half of them bounce back with an error.
Almost every crypto service you touch runs one. Exchanges limit how fast you can pull order books or fire orders. RPC providers limit how many blockchain queries your node key can make. Data APIs like CoinGecko limit how often you can poll prices on a free tier.
The car-governor image is close enough to start with. A speed limiter stops an engine past a set point, and an API rate limiter stops a client past a set request rate. But the crypto version is stricter and more specific, because it often meters by cost, not just by count.
When you cross the line, the service does one of two things. It rejects the request with a 429 Too Many Requests status, or it quietly delays it. Rejection is far more common, and it usually arrives with a hint about when to try again. Read that hint and half your problem is already solved.
The upside is that a limiter is predictable. Once you know its window and its threshold, you can pace your requests to stay under it instead of guessing why calls keep failing.
The limit exists to protect the service and everyone else using it. Understanding the reason makes the fix obvious, because you stop treating the 429 as random and start treating it as a budget.
A public exchange API might serve thousands of bots at once. Without a cap, a handful of aggressive scripts could starve everyone else of capacity. The rate limiter spreads access so one greedy client cannot hog the pipe.
Security is the second reason. A flood of requests is what a denial-of-service attack looks like, and the limiter is the first line that absorbs it before it reaches the matching engine or the node.
Then there is market integrity. Rapid place-and-cancel spam can paint a fake picture of demand, and rate limits are one brake on that behavior. This is the same territory as fake order-book activity, where flurries of orders create depth that never intends to fill.
The main reasons a crypto service throttles you come down to a short list:
So the cap is not hostile. It is the price of a shared, always-on service. Once you see the limiter as a budget you were handed, the job becomes spending it well rather than fighting it.
Every request you send runs through the same short checkpoint. The request arrives, the limiter checks a counter or a bucket tied to your identity, and it either lets the call through or returns a 429.
That identity is usually your API key or your IP address, sometimes both. The limiter keeps a running tally for you, resets or refills it over time, and compares each new call against your remaining allowance.
When it blocks you, the response often carries a Retry-After header. The HTTP specification defines this header as the number of seconds to wait before trying again. Reading it is the single best habit for anyone building against a crypto API. It turns a guessing game into a timer.
Here is where crypto trips people up. The unit being counted is frequently not the request. Binance charges each endpoint a request weight, so a heavy order-book snapshot might cost 50 while a simple ping costs 1. Alchemy meters in compute units per second, so a getLogs query can cost many times what a basic balance check costs.
The request path stays consistent across venues even as the metering changes:
So the mechanism is easy to reason about, but the accounting is not. If you assume one call equals one unit, you will blow your budget on the expensive endpoints and never understand why. The fix starts with learning what each call actually costs on the venue you use.
The algorithm behind the limiter decides how your requests are timed, and knowing it lets you pace a bot instead of hammering blindly. Four models cover almost everything you will meet in crypto.
The differences are not academic. Each one behaves differently at the edges, and that behavior is what decides whether your burst of calls sails through or gets chopped.
| Algorithm | What it means for your requests |
|---|---|
| Token bucket | You get a burst allowance that refills over time. Spend it fast and you must wait for tokens to top up. |
| Leaky bucket | Requests drain at a steady, fixed rate. Bursts queue or spill, so smooth pacing beats bursting. |
| Fixed window | The count resets on the clock. Two bursts either side of the reset can briefly double your effective rate. |
| Sliding window | The count moves with a rolling window, smoothing out the edge bursts a fixed window allows. |
Token bucket is the most common on exchanges, and it is friendly to bots that need short bursts. You can fire a cluster of calls, then ease off while the bucket refills.
Fixed window is the one that fools people. The counter resets on a clock boundary. So a bot that bursts right before and right after the reset can briefly double its rate, then eat a wall of 429s. Sliding window closes that gap by measuring a rolling period instead of a fixed slot.
The takeaway is to match your request rhythm to the model. Burst-and-rest suits a token bucket, while a leaky bucket rewards a steady drip. Read the venue docs, confirm which one applies, and time your loop to it.
Exchange limits are where most bot builders first get burned, and every major venue uses its own model. Naming the concrete approaches helps you tune request timing before you get throttled.
Two splits matter everywhere. Public endpoints, like fetching a ticker, usually have looser limits than private endpoints, like placing an order against your account. And REST and WebSocket connections are metered separately, which is your first clue toward a fix.
| Exchange | Limit model |
|---|---|
| Binance | Request weight per endpoint, with a total weight budget per interval. |
| Coinbase | Requests-per-second caps, differing by public and private endpoints. |
| Kraken | A call counter that decays over time rather than resetting on a clock. |
| Gemini | Requests-per-minute caps split across API groups. |
| Hyperliquid | Per-address limits tied to your wallet rather than a key. |
These models change, and the exact numbers change more often than the models do. Always confirm current figures in the venue’s own API documentation before you hard-code a pace into a bot. Treat any number you read online, including here, as a starting point to verify.
These caps bite hardest on the high-frequency venues. Perpetual futures venues reward tight, fast order management. So a scalping or market-making bot there hits private-endpoint limits long before a casual spot trader notices. The same goes for crypto derivatives desks running heavy order flow.
So the practical move is to map your bot to the venue’s model first. Know whether you are spending weight, calls, or per-second slots, and know whether your heaviest calls are public or private, before you scale the request rate.
Not every 429 comes from an exchange. If you are building a dApp, an indexer, or a portfolio tracker, the limiter blocking you is more likely an RPC provider or a data feed.
RPC providers meter more strictly than raw call counts suggest. Infura’s free tier caps daily requests in the low hundreds of thousands. Alchemy meters in compute units per second, so an expensive query drains your budget faster than a cheap one. QuickNode uses its own credit model with similar throttling on entry tiers.
Data APIs are often even tighter on the free plan. CoinGecko and CoinMarketCap cap free-tier calls hard, which is why a tracker that polls hundreds of coins every few seconds runs into a wall almost immediately.
A common trigger is polling a value that updates constantly. The funding rate is a classic example. A bot watching perps might request it every second across many markets, burning through a data-API budget without placing a single trade.
The mistake to avoid on RPC and data APIs comes down to treating all calls as equal:
So before you scale a tracker or a dApp, price your calls. Find the expensive ones, cut the ones polling data that barely moves, and you will often stay under the free tier far longer than you expected.
This is the part most people came for. Getting past 429s is not one trick. It is a short stack of fixes, applied in order, until your request rate sits safely under the cap.
Start with the response the limiter already gave you. When a 429 arrives with a Retry-After header, wait exactly that long before retrying. Ignoring it and hammering the endpoint is the fastest way to make things worse.
When there is no header, or you want a general safety net, use exponential backoff with jitter. Double the wait after each failure and add a small random offset so your retries do not stampede in lockstep with everyone else’s.
The fixes worth trying, roughly in the order you should reach for them:
WebSocket is the underrated one. Instead of polling an exchange for price updates a few times a second, you open one stream and let the venue push updates to you. That single change can erase most of your request volume overnight.
Automated setups fire the most requests, so backoff and batching help most there. A copy-trading system that mirrors a lead trader across many followers multiplies order volume fast. Without pacing, it will trip limits before the strategy ever proves itself.
Work in that order, since the cheap fixes solve most problems. Backoff and WebSocket alone clear the majority of 429s. Paying for a higher tier is the last resort, not the first.
You do not need to rebuild anything today. A few concrete moves will settle most rate-limit trouble within a week, and none of them require paying for a bigger plan up front.
Start by finding the documented limits for the exact venue or provider you use. Write down three things: the window, the threshold, and the metering unit. That last one is where most people get caught, since a weight-based venue and a compute-unit provider count the same loop very differently. Then log your own request rate for a day so you can see how close to the cap you actually run.
Numbers on paper often surprise you here. A bot that feels calm might sit at ninety percent of its budget during volatile hours, then tip over the moment the market moves. Knowing your real baseline turns the next fixes from guesswork into targeted tuning.
From there, work through the practical fixes:
Do those in order and most builders find the 429s stop before they ever reach for a paid upgrade. The rate limiter was never the enemy. It was just a budget you had not learned to spend yet.
A rate limiter counts how many requests you send to a service. It blocks any that go over a set limit within a time window. In crypto, exchanges, RPC nodes, and data APIs all run one to keep any single client from overwhelming the service. Cross the line and you get a 429 error instead of your data.
A 429 means a rate limiter rejected your request because you sent too many too fast for your API key or IP. The service tracked your volume, saw you cross its cap, and refused the call rather than serving it. Check the response for a Retry-After header, wait that long, and slow your request rate before retrying.
A rate limiter can apply per IP address, per API key, or both, and it depends entirely on the venue. Public endpoints are often limited by IP, while authenticated private endpoints are usually limited by API key. Some venues, like certain on-chain protocols, tie limits to your wallet address instead. Always confirm which one the rate limiter uses in the provider’s documentation.
A rate limiter sets the hard cap and rejects requests over it, usually with a 429, while throttling slows requests down to keep them under that ceiling. In practice the words overlap and many services use them loosely. The useful distinction is that limiting blocks excess calls outright and throttling paces your calls so fewer get blocked in the first place.
Tripping a rate limiter occasionally just returns a 429 and is not a ban. But repeatedly ignoring the limit and hammering an endpoint can escalate to a temporary IP block or, on some exchanges, a longer restriction. Respect the Retry-After header, add backoff, and you will almost never risk more than a brief cooldown from the rate limiter.