API Rate Limits & Request Frequency

All exchanges enforce API rate limits.

These limits restrict how frequently software may:

Request market data
Fetch balances
Place or query orders

This page explains:

The typical rate limits of supported exchanges
How Aurono operates within those limits
What the implications are for strategy execution

What API Rate Limits Are

An API rate limit defines:

How many requests are allowed
Within a given time window
Per API key or account

If a limit is exceeded, the exchange may:

Temporarily block requests
Throttle responses
Return rate-limit errors

Aurono is designed to avoid this.

Supported Exchanges and Their Limits

The exact limits are defined by the exchanges and may change.
The values below reflect typical documented limits at the time of writing.

Bitvavo

Bitvavo uses a weight-based rate limiting system.

Typical characteristics:

~1000 requests per minute per API key
Different endpoints have different weights
Order placement and balance requests are heavier than market data

Bitvavo provides clear rate-limit headers in API responses.

Kraken

Kraken enforces a tiered rate limit system.

Typical characteristics:

Private endpoints: limited by a “request counter”
Counter refills gradually over time
Order placement and order status checks consume more capacity

Kraken may temporarily reject requests if limits are exceeded.

Coinbase (Advanced Trade API)

Coinbase enforces strict per-endpoint limits.

Typical characteristics:

Relatively low request limits compared to other exchanges
Separate limits for public and private endpoints
Stricter enforcement during peak periods

Coinbase has the most restrictive rate limits of the three supported exchanges.

How Aurono Operates Within Rate Limits

Aurono is designed to be low-frequency by design.

Aurono:

Evaluates strategies only at candle close
Fetches market data only when needed
Caches exchange metadata and constraints
Avoids polling loops and live price streams

Aurono does not:

Continuously poll prices
React to every market tick
Refresh balances unnecessarily

This keeps API usage minimal and predictable.

Strategy Evaluation Frequency

API usage scales primarily with:

Number of strategies
Number of exchanges used
Selected timeframes

Example:

A 1h strategy generates at most one evaluation per hour
A 4h strategy generates one evaluation every 4 hours
A daily strategy generates one evaluation per day

This design naturally limits API usage.

Order Placement and Follow-Up

When a trade is triggered, Aurono performs a short sequence of requests:

Fetch current ticker price (for amount calculation)
Submit a limit order
Poll order status until filled or finalized
Fetch final execution details

This sequence is bounded and does not loop indefinitely.

What Happens If a Rate Limit Is Hit

If an exchange rate limit is reached:

Aurono logs the rate-limit response
The current action is skipped or delayed
No repeated retry storm occurs

Aurono does not:

Aggressively retry requests
Escalate request frequency
Risk account-level blocking

Rate limits are treated as a hard external constraint.

Practical Implications for Users

In normal usage:

Rate limits are rarely reached
One or several strategies are safe
Multiple timeframes are fine

Potential issues may arise if:

Many strategies run on very short timeframes
Multiple exchanges are used simultaneously
Exchange-side limits are temporarily tightened

These situations are uncommon for Aurono’s intended use.

Why This Matters

Respecting rate limits ensures:

Stable exchange connectivity
Reliable order execution