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);
}

// Sliding window limiter with queue
class ProductionLimiter {
  private queue: Array<{ timestamp: number; resolve: () => void }> = [];
  private processing = false;
 
  constructor(
    private rps: number,
    private windowMs: number = 1000,
  ) {}
 
  async acquire(): Promise<void> {
    return new Promise((resolve) => {
      this.queue.push({ timestamp: Date.now(), resolve });
      this.processQueue();
    });
  }
 
  private processQueue() {
    if (this.processing) return;
    this.processing = true;
 
    const process = () => {
      if (this.queue.length === 0) {
        this.processing = false;
        return;
      }
 
      const now = Date.now();
      const windowStart = now - this.windowMs;
 
      // Remove old entries
      this.queue = this.queue.filter((item) => item.timestamp > windowStart);
 
      // Check if we can process the next request
      if (this.queue.length <= this.rps) {
        const item = this.queue.shift()!;
        item.resolve();
        setTimeout(process, this.windowMs / this.rps);
      } else {
        setTimeout(process, 100); // Check again soon
      }
    };
 
    process();
  }
}
 
// Usage
const limiter = new ProductionLimiter(50); // ENTERPRISE_50
 
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]),
]);