Rate Limits

Rate limiting caps how many BNB Smart Chain calls a key may issue in a window, which keeps the shared chainId 56 nodes responsive and protects every tenant from noisy neighbors. TheRPC enforces it at several layers at once: a per-second ceiling, a per-minute budget, a per-day quota, and a cap on concurrent connections. The exact figures scale with your subscription tier rather than being fixed, and you can always read the live numbers for your key on the TheRPC dashboard.

Error Responses

Cross any of those thresholds and the BNB Smart Chain endpoint answers with a JSON-RPC error carrying code -32029 and a "Rate limit exceeded" message, as shown below. The same response also sets three HTTP headers (X-RateLimit-Limit, X-RateLimit-Remaining, and X-RateLimit-Reset) so your client can see how much budget is left and when the window rolls over without parsing the body.

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 tactics keep most BNB Smart Chain workloads comfortably under the ceiling. First, retry rejected calls with exponential backoff so a brief spike settles instead of hammering the gateway. Second, fold several reads into one batch request to spend a single slot on many results. Third, replace polling loops with WebSocket subscriptions so the chain pushes updates to you. The examples that follow show each in turn.

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 anything real-time on BNB Smart Chain (new heads roughly every three seconds, pending transactions, or contract logs), eth_subscribe over the wss://bsc.therpc.io/YOUR_API_KEY socket lets the node push events to you and removes the repeated polling that burns through your quota. See the eth_subscribe reference for the subscription types and payload shapes.

Monitoring

Dashboard metrics: track call volume and remaining quota per key on TheRPC.
Response headers: read X-RateLimit-Remaining and X-RateLimit-Reset on each reply.
Usage alerts: get notified as a key approaches its BNB Smart Chain limits.

Quota Management

Read the X-RateLimit-Remaining and X-RateLimit-Reset headers off each BNB Smart Chain response programmatically, as the tracking helper below does, and you can throttle yourself before the gateway has to. Pair that with caching: slowly-changing values such as a confirmed block, a token's decimals, or deployed contract bytecode rarely change, so caching them locally collapses many redundant calls into one and stretches your quota.

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 along several axes for BNB Smart Chain access: the allowed request rate, the daily call quota, how many concurrent WebSocket connections you may hold, and the number of active subscriptions per connection. Higher tiers also unlock archive-state queries, the debug_ namespace, and the trace_ API, which the free tier does not expose. Compare the full breakdown side by side on the pricing page before you commit.

Upgrade Options

Optimize requests: collapse chatty reads into batches and drop calls you do not need.
Add caching: store stable BNB Smart Chain results so you stop re-fetching them.
Switch to WebSocket subscriptions: let eth_subscribe push events instead of polling.
Upgrade your plan: move to a higher tier for more rate and quota plus extra connections.