What are the rate limits for the Kraken API

Kraken API enforces 15 public requests per minute per IP and 20 private requests per minute per account, with rate limits resetting at the start of each minute.

Aug 12, 2025 at 08:00 pm

Understanding Kraken API Rate Limits

The Kraken API implements rate limiting to ensure fair usage and maintain system stability for all users. These limits are crucial for developers and traders relying on real-time data or automated trading strategies. Each API endpoint has specific thresholds based on the type of request—public or private. Public endpoints, such as those retrieving ticker data or order books, are subject to less stringent limits compared to private endpoints, which involve account-specific actions like placing orders or checking balances.

For public API endpoints, Kraken allows up to 15 requests per minute per IP address. This means that if your application sends more than 15 calls within a 60-second window to endpoints like /public/Ticker or /public/Depth, subsequent requests will be rejected with a 429 Too Many Requests HTTP status code. This limit is enforced at the network level and applies regardless of authentication status.

Private API Endpoint Restrictions

When it comes to private endpoints, such as /private/AddOrder or /private/Balance, the rate limits are tied to the user account rather than the IP address. Kraken allows 20 calls per minute for authenticated requests. These endpoints require valid API keys and signatures, and exceeding the limit results in temporary blocking of further private requests until the next minute window resets.

It is important to note that each private API call consumes one unit, and some complex operations may consume multiple units depending on backend processing load. For example, placing a margin order might count as two calls due to additional validation steps. Developers should monitor their usage through response headers, particularly the X-BS-Unit-Current, X-BS-Unit-Limit, and X-BS-Unit-Reset fields, which provide real-time insight into current consumption and reset timing.

Managing Rate Limits in Practice

To avoid hitting rate limits, developers should implement throttling mechanisms in their applications. One effective method is to use a token bucket algorithm that tracks the number of requests made and delays execution when nearing the threshold. For instance:

• Use a delay of at least 4 seconds between public API calls to stay under the 15-per-minute limit.
• For private calls, space requests by 3 seconds or more to remain within the 20-call threshold.
• Implement exponential backoff when receiving 429 responses, starting with a 1-second pause and doubling the delay after each failed attempt.

Additionally, caching responses from public endpoints can significantly reduce the number of API calls. For example, storing ticker data for 30 seconds before refreshing avoids redundant requests while maintaining acceptable data freshness.

Configuring API Keys for Optimal Performance

When creating API keys on Kraken, users can customize permissions and IP access restrictions. To optimize rate limit usage:

• Generate dedicated API keys for different services, such as one for market data and another for order execution. This allows better tracking and isolation of usage.
• Restrict each key to specific IP addresses to prevent unauthorized use and ensure consistent rate limit attribution.
• Enable query whitelisting to pre-approve certain endpoints, which may improve processing speed and reduce overhead.

After generating a key, always test it in a sandbox environment using low-frequency calls before deploying in production. Monitor the X-RateLimit-* headers in API responses to verify compliance. These headers include:

• X-RateLimit-Limit: The total number of allowed requests per minute.
• X-RateLimit-Remaining: The number of requests left in the current window.
• X-RateLimit-Reset: Unix timestamp indicating when the counter resets.

Parsing these headers enables dynamic adjustment of request frequency without hardcoding delays.

Handling Rate Limit Errors Programmatically

When a rate limit is exceeded, Kraken returns a JSON response with the error code EAPI:Rate limit exceeded. Applications must handle this gracefully. A robust error-handling routine includes:

• Checking the HTTP status code and response body for rate limit indicators.
• Logging the event with timestamp and endpoint details for debugging.
• Pausing execution until the reset time indicated in X-BS-Unit-Reset.
• Retrying the request only after the cooling period.

For example, in Python, you can use the requests library to inspect headers and manage delays:

import requests
import time
response = requests.get("https://api.kraken.com/0/public/Ticker", params={"pair": "XBTUSD"})
if response.status_code == 429:
reset_time = int(response.headers.get("X-BS-Unit-Reset", 0))
sleep_duration = max(reset_time - int(time.time()), 1)
time.sleep(sleep_duration)
This ensures the application respects rate limits and avoids repeated failures.
Best Practices for High-Frequency Applications

Applications requiring frequent data updates, such as algorithmic trading bots, must adopt advanced strategies:

• Batch requests where possible. For example, fetching multiple asset pairs in a single call to /public/Ticker instead of making individual requests.
• Use WebSocket feeds for real-time data. Kraken’s WebSocket API provides order book updates, trades, and tickers without consuming REST rate limits.
• Distribute load across multiple IP addresses using proxy servers or cloud instances, each with its own public rate limit allowance.
• Schedule intensive operations during off-peak hours to minimize competition for resources.

WebSocket connections themselves have limits—Kraken allows up to 10 concurrent connections per IP. Each connection can subscribe to multiple channels, but excessive message rates may trigger disconnection.

Frequently Asked Questions

Does Kraken differentiate between API tiers based on account level?

No, Kraken does not offer tiered API rate limits based on account verification level or trading volume. All users receive the same baseline limits: 15 public calls per minute per IP and 20 private calls per minute per account. There are no premium API plans with increased quotas.

Can I increase my rate limit by contacting Kraken support?

Kraken does not provide options to increase rate limits for individual accounts. The limits are fixed to maintain platform stability. Users needing higher throughput are encouraged to optimize their code, use WebSockets, or distribute requests across multiple IPs.

Do failed API requests count toward the rate limit?

Yes, all requests sent to the API, including those that fail due to invalid parameters or authentication errors, count toward the rate limit. Only successfully authenticated and processed requests return rate limit headers, but the counter increments regardless of outcome.

How are rate limit windows calculated—rolling or fixed?

Kraken uses fixed time windows based on the clock minute. The counter resets at the start of each minute (e.g., :00 seconds). If you make 15 public calls at 12:00:55, you must wait until 12:01:00 to make more, even though only 5 seconds have passed.