Rate Limits Quick Reference

How many requests per second do you need?
│
├─ Less than 1 req/s
│  └─ Do you need to bypass IP restrictions?
│     ├─ No → <ion-icon name="checkmark-circle" style={{verticalAlign: "middle", fontSize: "1.2em", color: "#10b981"}}></ion-icon> FREE tier
│     └─ Yes → <ion-icon name="checkmark-circle" style={{verticalAlign: "middle", fontSize: "1.2em", color: "#10b981"}}></ion-icon> BASIC tier
│
├─ Between 1-10 req/s
│  └─ Do you need priority support?
│     ├─ No → <ion-icon name="checkmark-circle" style={{verticalAlign: "middle", fontSize: "1.2em", color: "#10b981"}}></ion-icon> BASIC tier
│     └─ Yes → <ion-icon name="checkmark-circle" style={{verticalAlign: "middle", fontSize: "1.2em", color: "#10b981"}}></ion-icon> PRO tier
│
├─ Between 10-50 req/s
│  └─ <ion-icon name="checkmark-circle" style={{verticalAlign: "middle", fontSize: "1.2em", color: "#10b981"}}></ion-icon> ENTERPRISE_50 tier
│
└─ More than 50 req/s
   └─ <ion-icon name="checkmark-circle" style={{verticalAlign: "middle", fontSize: "1.2em", color: "#10b981"}}></ion-icon> ENTERPRISE_500 tier or custom

Request arrives
    ↓
Check User RPS (1 req/s) ──── FAIL → 429 Too Many Requests
    ↓ PASS
    ↓
Check IP RPS (1 req/s) ──── FAIL → 429 Too Many Requests
    ↓ PASS
    ↓
Process Request → 200 OK

Request arrives
    ↓
Check User RPS (tier-specific) ──── FAIL → 429 Too Many Requests
    ↓ PASS
    ↓
Process Request → 200 OK

Response: 429 Too Many Requests
Current RPS: ~2 requests/second
Tier: FREE

Normal traffic: 30 req/s
Peak traffic: 200 req/s (during NFT drops, events)
Current tier: ENTERPRISE_50 (50 req/s)

Users: Global (US, EU, Asia)
Requirements: Low latency, high availability
Current setup: Single key, single region

// Simple delay-based limiter
class SimpleLimiter {
  constructor(rps) {
    this.delay = 1000 / rps;
    this.lastCall = 0;
  }
 
  async wait() {
    const now = Date.now();
    const timeSinceLastCall = now - this.lastCall;
 
    if (timeSinceLastCall < this.delay) {
      await new Promise((r) => setTimeout(r, this.delay - timeSinceLastCall));
    }
 
    this.lastCall = Date.now();
  }
}
 
// Usage (BASIC tier = 10 RPS)
const limiter = new SimpleLimiter(10);
 
async function makeRequest(url) {
  await limiter.wait();
  return fetch(url);
}

class RequestLimiter {
  private tail: Promise<void> = Promise.resolve();
  private nextStart = 0;
  private readonly intervalMs: number;
 
  constructor(requestsPerSecond: number) {
    if (!Number.isFinite(requestsPerSecond) || requestsPerSecond <= 0) {
      throw new Error("requestsPerSecond must be a positive finite number");
    }
    this.intervalMs = 1000 / requestsPerSecond;
  }
 
  acquire(): Promise<void> {
    const turn = this.tail.then(async () => {
      const waitMs = Math.max(0, this.nextStart - performance.now());
      if (waitMs > 0) {
        await new Promise<void>((resolve) => setTimeout(resolve, waitMs));
      }
      this.nextStart = performance.now() + this.intervalMs;
    });
    this.tail = turn.catch(() => {});
    return turn;
  }
}
 
// Example pacing only; replace with your verified account limit.
const limiter = new RequestLimiter(10);
 
async function makeRequest(url: string) {
  await limiter.acquire();
  return fetch(url);
}

// Automatically batches JSON-RPC requests
class BatchHelper {
  constructor(url, maxBatchSize = 10, flushIntervalMs = 100) {
    this.url = url;
    this.maxBatchSize = maxBatchSize;
    this.flushIntervalMs = flushIntervalMs;
    this.pendingRequests = [];
    this.timer = null;
  }
 
  request(method, params) {
    return new Promise((resolve, reject) => {
      this.pendingRequests.push({
        method,
        params,
        resolve,
        reject,
        id: Date.now() + Math.random(),
      });
 
      if (this.pendingRequests.length >= this.maxBatchSize) {
        this.flush();
      } else if (!this.timer) {
        this.timer = setTimeout(() => this.flush(), this.flushIntervalMs);
      }
    });
  }
 
  async flush() {
    if (this.timer) {
      clearTimeout(this.timer);
      this.timer = null;
    }
 
    if (this.pendingRequests.length === 0) return;
 
    const batch = this.pendingRequests.splice(0, this.maxBatchSize);
 
    const payload = batch.map((req) => ({
      jsonrpc: "2.0",
      id: req.id,
      method: req.method,
      params: req.params,
    }));
 
    try {
      const response = await fetch(this.url, {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify(payload),
      });
 
      const results = await response.json();
 
      results.forEach((result) => {
        const req = batch.find((r) => r.id === result.id);
        if (req) {
          if (result.error) {
            req.reject(result.error);
          } else {
            req.resolve(result.result);
          }
        }
      });
    } catch (error) {
      batch.forEach((req) => req.reject(error));
    }
  }
}
 
// Usage
const batcher = new BatchHelper("https://api.bex.co/eth/YOUR_KEY");
 
// These 3 calls will be batched into 1 HTTP request
const [block1, block2, block3] = await Promise.all([
  batcher.request("eth_getBlockByNumber", ["0x1", false]),
  batcher.request("eth_getBlockByNumber", ["0x2", false]),
  batcher.request("eth_getBlockByNumber", ["0x3", false]),
]);