Rate Limits

Rate limiting caps how many requests you can send to the Avalanche C-Chain in a given window. TheRPC applies it to keep the service fast and fair for everyone, preventing any single client from overwhelming the shared infrastructure. Limits are enforced at several levels at once — per second, per minute, per day, and on the number of concurrent connections — so a burst that passes the per-second check can still hit the daily quota. The exact numbers depend on your subscription plan and are always visible in your TheRPC dashboard.

Error Responses

When you exceed a limit on the Avalanche C-Chain, TheRPC returns a JSON-RPC error with code -32029 and the message Rate limit exceeded instead of a result. Alongside the body, the HTTP response carries rate-limit metadata in its headers — X-RateLimit-Limit, X-RateLimit-Remaining, and X-RateLimit-Reset — so your client can read how much quota is left and when the window resets, and back off before it gets throttled again.

Rate Limit Error — JSON-RPC

1{
2  "jsonrpc": "2.0",
3  "error": {
4    "code": -32029,
5    "message": "Rate limit exceeded"
6  },
7  "id": 1
8}

Rate Limit Response Headers

1X-RateLimit-Limit: 10
2X-RateLimit-Remaining: 0
3X-RateLimit-Reset: 1628696400

Best Practices

Three strategies keep your Avalanche C-Chain integration comfortably under its limits. First, retry rejected calls with exponential backoff so you recover from transient -32029 errors without hammering the endpoint. Second, batch independent reads into a single JSON-RPC request to cut round trips. Third, replace polling with WebSocket subscriptions for real-time data so you receive updates as they happen instead of repeatedly asking. The sections below show each in practice.

Implement Retries

1async function callWithRetry(method, params, maxRetries = 3) {
2  for (let i = 0; i < maxRetries; i++) {
3    try {
4      const response = await makeRequest(method, params);
5      return response;
6    } catch (error) {
7      if (error.code === -32029) {
8        // Rate limit exceeded
9        const backoffTime = Math.pow(2, i) * 1000;
10        await new Promise((resolve) => setTimeout(resolve, backoffTime));
11        continue;
12      }
13      throw error;
14    }
15  }
16  throw new Error('Max retries exceeded');
17}

Batch Requests

1[
2  {
3    "jsonrpc": "2.0",
4    "method": "eth_getBalance",
5    "params": ["0x742d35Cc6634C0532925a3b844Bc454e4438f44e", "latest"],
6    "id": 1
7  },
8  {
9    "jsonrpc": "2.0",
10    "method": "eth_blockNumber",
11    "params": [],
12    "id": 2
13  }
14]

Use WebSocket Subscriptions

For real-time data on the Avalanche C-Chain, eth_subscribe over WebSocket eliminates polling overhead entirely. Instead of sending repeated requests to check for new blocks or event logs — each one counting against your rate limit — you open a single subscription and the node pushes updates to you as they occur. On a chain with one-to-two-second finality, this both reduces request volume and lowers latency. See the eth_subscribe reference for details.

Monitoring

• Dashboard metrics — watch your Avalanche C-Chain request volume, error rates, and remaining quota in the TheRPC dashboard.
• Response headers — read X-RateLimit-Limit, X-RateLimit-Remaining, and X-RateLimit-Reset on every response to track usage in real time.
• Usage alerts — set alerts so you are notified before you hit a limit, giving you time to throttle, cache, or upgrade.

Quota Management

Manage your Avalanche C-Chain quota proactively by reading the rate-limit headers programmatically — pull X-RateLimit-Remaining and X-RateLimit-Reset off each response and slow down before you run out. Pair this with response caching: values that change slowly, such as block data, contract bytecode from eth_getCode, or a confirmed transaction receipt, can be cached locally so you serve repeat reads from memory instead of spending a request every time. Together these cut your request volume substantially without losing freshness where it matters.

Track Usage

1function trackApiUsage(response) {
2  const limits = {
3    limit: response.headers['X-RateLimit-Limit'],
4    remaining: response.headers['X-RateLimit-Remaining'],
5    reset: response.headers['X-RateLimit-Reset'],
6  };
7 
8  console.log(`API calls remaining: ${limits.remaining}/${limits.limit}`);
9}

Implement Caching

1const cache = new Map();
2 
3async function getCachedBlockNumber(cacheTime = 5000) {
4  const cached = cache.get('blockNumber');
5  if (cached && Date.now() - cached.timestamp < cacheTime) {
6    return cached.value;
7  }
8 
9  const newValue = await web3.eth.getBlockNumber();
10  cache.set('blockNumber', {
11    value: newValue,
12    timestamp: Date.now(),
13  });
14 
15  return newValue;
16}

Plan Limits

Plans differ across several dimensions on the Avalanche C-Chain: the request rate you can sustain, your daily quota, the number of concurrent WebSocket connections, and how many active subscriptions you can hold. Higher-tier plans also unlock advanced capabilities — archive data for historical state queries, the debug_ methods, and the trace_ API for full transaction tracing. To see exactly what each tier includes and pick the right one for your workload, compare them on the pricing page.

Upgrade Options

• Optimize your requests — batch independent calls and drop any redundant reads so each Avalanche C-Chain request earns its place.
• Add caching — store slowly-changing data like block info and contract code locally to avoid repeat calls.
• Switch to WebSocket subscriptions — replace polling loops with eth_subscribe to cut request volume for real-time data.
• Upgrade your plan — when you consistently hit limits, move to a higher tier for more throughput, a larger daily quota, and advanced method access.