Rate limits

class MasterIDThrottler {
  private lastRequestTime = 0;
  private minIntervalMs: number;

  constructor(requestsPerMinute: number) {
    this.minIntervalMs = 60_000 / requestsPerMinute;
  }

  async ready(): Promise<void> {
    const now = Date.now();
    const elapsed = now - this.lastRequestTime;
    const delay = Math.max(0, this.minIntervalMs - elapsed);
    if (delay > 0) {
      await new Promise((r) => setTimeout(r, delay));
    }
    this.lastRequestTime = Date.now();
  }
}

const throttler = new MasterIDThrottler(60);

async function throttledCall(path: string, init?: RequestInit) {
  await throttler.ready();
  return fetch(`https://masterid.me/api/public/v1${path}`, {
    ...init,
    headers: {
      "X-API-Key": process.env.MASTERID_API_KEY!,
      "X-API-Secret": process.env.MASTERID_API_SECRET!,
      "Content-Type": "application/json",
      ...init?.headers,
    },
  });
}

import os
import time
import requests

BASE_URL = "https://masterid.me/api/public/v1"


class MasterIDThrottler:
    def __init__(self, requests_per_minute: int):
        self.min_interval = 60.0 / requests_per_minute
        self.last_request_time = 0.0

    def ready(self):
        now = time.time()
        elapsed = now - self.last_request_time
        delay = max(0.0, self.min_interval - elapsed)
        if delay:
            time.sleep(delay)
        self.last_request_time = time.time()


throttler = MasterIDThrottler(requests_per_minute=60)


def throttled_call(path, method="GET", **kwargs):
    throttler.ready()
    headers = {
        "X-API-Key": os.environ["MASTERID_API_KEY"],
        "X-API-Secret": os.environ["MASTERID_API_SECRET"],
        "Content-Type": "application/json",
    }
    headers.update(kwargs.pop("headers", {}))
    return requests.request(
        method,
        f"{BASE_URL}{path}",
        headers=headers,
        **kwargs,
    )