Rate Limits

RateLimit-Limit: 10
RateLimit-Remaining: 7
RateLimit-Reset: 1699884000

const resetTime = new Date(headers["RateLimit-Reset"] * 1000);
console.log("Rate limit resets at:", resetTime.toLocaleString());

{
  "error": "Rate limit exceeded",
  "message": "Too many requests too quickly. Maximum 10 uploads per 10 seconds allowed.",
  "limit": 10,
  "window": "10 seconds",
  "retryAfter": "8",
  "hint": "Slow down! You're making requests too fast. Wait a few seconds between uploads."
}

{
  "error": "Rate limit exceeded",
  "message": "Too many upload requests. Maximum 20 uploads per minute allowed per API key.",
  "limit": 20,
  "window": "1 minute",
  "retryAfter": "23",
  "hint": "You've used your minute quota. Wait for the limit to reset or implement client-side queueing."
}

{
  "error": "Rate limit exceeded",
  "message": "Too many search requests. Maximum 10 searches per minute allowed.",
  "limit": 10,
  "window": "1 minute",
  "retryAfter": "45",
  "hint": "Search operations are computationally expensive. Please reduce query frequency."
}

{
  "error": "Rate limit exceeded",
  "message": "Too many read requests. Maximum 100 reads per minute allowed.",
  "limit": 100,
  "window": "1 minute",
  "retryAfter": "12"
}

async function makeRequest(url, options) {
  const response = await fetch(url, options);

  // Check remaining requests
  const remaining = parseInt(response.headers.get("RateLimit-Remaining"));
  const reset = parseInt(response.headers.get("RateLimit-Reset"));

  console.log(`Requests remaining: ${remaining}`);

  if (remaining === 0) {
    const waitTime = reset * 1000 - Date.now();
    console.log(`Rate limit reached. Waiting ${waitTime}ms...`);
    await new Promise((resolve) => setTimeout(resolve, waitTime));
  }

  return response;
}

async function requestWithBackoff(url, options, maxRetries = 3) {
  for (let i = 0; i < maxRetries; i++) {
    const response = await fetch(url, options);

    if (response.status !== 429) {
      return response;
    }

    // Rate limited - wait before retry
    const retryAfter = parseInt(response.headers.get("Retry-After") || "5");
    const waitTime = retryAfter * 1000 * Math.pow(2, i); // Exponential backoff

    console.log(
      `Rate limited. Waiting ${waitTime}ms before retry ${i + 1}/${maxRetries}...`
    );
    await new Promise((resolve) => setTimeout(resolve, waitTime));
  }

  throw new Error("Max retries reached");
}

class RateLimitedQueue {
  constructor(limit, windowMs) {
    this.limit = limit;
    this.windowMs = windowMs;
    this.queue = [];
    this.processing = false;
  }

  async add(fn) {
    return new Promise((resolve, reject) => {
      this.queue.push({ fn, resolve, reject });
      this.process();
    });
  }

  async process() {
    if (this.processing || this.queue.length === 0) return;

    this.processing = true;
    const timestamps = [];

    while (this.queue.length > 0) {
      const now = Date.now();

      // Remove timestamps outside the window
      const cutoff = now - this.windowMs;
      while (timestamps.length > 0 && timestamps[0] < cutoff) {
        timestamps.shift();
      }

      // Check if we can make a request
      if (timestamps.length < this.limit) {
        const { fn, resolve, reject } = this.queue.shift();
        timestamps.push(now);

        try {
          const result = await fn();
          resolve(result);
        } catch (error) {
          reject(error);
        }
      } else {
        // Wait until oldest timestamp expires
        const waitTime = timestamps[0] + this.windowMs - now;
        await new Promise((resolve) => setTimeout(resolve, waitTime));
      }
    }

    this.processing = false;
  }
}

// Usage for uploads (20 per minute)
const uploadQueue = new RateLimitedQueue(20, 60000);

// Queue upload requests
const results = await Promise.all(
  files.map((file) => uploadQueue.add(() => uploadFile(file)))
);

class RateLimitMonitor {
  constructor() {
    this.requests = {
      uploads: [],
      searches: [],
      reads: [],
    };
  }

  trackRequest(type) {
    const now = Date.now();
    this.requests[type].push(now);

    // Clean old entries (older than 1 minute)
    const cutoff = now - 60000;
    this.requests[type] = this.requests[type].filter((t) => t > cutoff);
  }

  getUsage(type) {
    const limits = {
      uploads: 20,
      searches: 10,
      reads: 100,
    };

    const used = this.requests[type].length;
    const limit = limits[type];
    const remaining = limit - used;

    return {
      used,
      limit,
      remaining,
      percentUsed: (used / limit) * 100,
    };
  }

  canMakeRequest(type) {
    const usage = this.getUsage(type);
    return usage.remaining > 0;
  }
}

// Usage
const monitor = new RateLimitMonitor();

async function uploadWithMonitoring(file) {
  if (!monitor.canMakeRequest("uploads")) {
    throw new Error("Upload rate limit would be exceeded");
  }

  const result = await uploadFile(file);
  monitor.trackRequest("uploads");

  const usage = monitor.getUsage("uploads");
  console.log(
    `Uploads: ${usage.used}/${usage.limit} (${usage.remaining} remaining)`
  );

  return result;
}