Pagination and time windows

# Second page of 100
curl -sS "https://api.opentype.dev/v1/runs?limit=100&offset=100" \
  -H "Authorization: Bearer $OPENTYPE_API_KEY"

async function allRuns() {
  const seen = new Map<string, any>();
  const limit = 100;
  for (let offset = 0; ; offset += limit) {
    const res = await fetch(`https://api.opentype.dev/v1/runs?limit=${limit}&offset=${offset}`, {
      headers: { Authorization: `Bearer ${process.env.OPENTYPE_API_KEY}` },
    });
    const body = await res.json();
    if (!res.ok) throw new Error(`${res.status} ${body.error.code} (${body.error.request_id})`);
    for (const run of body.runs) seen.set(run.run_id, run); // new runs shift pages: dedupe
    if (body.runs.length < body.limit) return [...seen.values()];
  }
}

import os
import requests

def all_runs() -> list[dict]:
    seen: dict[str, dict] = {}
    limit, offset = 100, 0
    while True:
        res = requests.get(
            "https://api.opentype.dev/v1/runs",
            params={"limit": limit, "offset": offset},
            headers={"Authorization": f"Bearer {os.environ['OPENTYPE_API_KEY']}"},
            timeout=30,
        )
        body = res.json()
        if not res.ok:
            raise RuntimeError(f"{res.status_code} {body['error']['code']} ({body['error']['request_id']})")
        for run in body["runs"]:
            seen[run["run_id"]] = run  # new runs shift pages: dedupe
        if len(body["runs"]) < body["limit"]:
            return list(seen.values())
        offset += limit

curl -sS -G https://api.opentype.dev/v1/usage/ledger \
  -H "Authorization: Bearer $OPENTYPE_API_KEY" \
  --data-urlencode "start_at=2026-09-01T00:00:00Z" \
  --data-urlencode "end_at=2026-09-24T10:12:04Z" \
  --data-urlencode "limit=200"

const iso = (d: Date) => d.toISOString().replace(/\.\d{3}Z$/, "Z"); // YYYY-MM-DDTHH:MM:SSZ

async function ledger(startAt: string, endAt: string) {
  const seen = new Map<string, any>();
  let end = endAt;
  for (;;) {
    const url = new URL("https://api.opentype.dev/v1/usage/ledger");
    url.search = new URLSearchParams({ start_at: startAt, end_at: end, limit: "200" }).toString();
    const res = await fetch(url, { headers: { Authorization: `Bearer ${process.env.OPENTYPE_API_KEY}` } });
    if (!res.ok) throw new Error(`${res.status} ${await res.text()}`);
    const { entries } = await res.json();
    let added = 0;
    for (const e of entries) {
      const key = `${e.run_id}/${e.retry_ordinal}`;
      if (!seen.has(key)) (seen.set(key, e), added++);
    }
    if (entries.length < 200 || added === 0) return [...seen.values()];
    // One second past the oldest entry, so entries sharing that second are not skipped.
    const oldest = new Date(entries[entries.length - 1].created_at);
    end = iso(new Date(oldest.getTime() + 1000));
  }
}

await ledger("2026-09-01T00:00:00Z", "2026-10-01T00:00:00Z");

import os
from datetime import datetime, timedelta

import requests

FMT = "%Y-%m-%dT%H:%M:%SZ"

def ledger(start_at: str, end_at: str) -> list[dict]:
    seen: dict[tuple[str, int], dict] = {}
    end = end_at
    while True:
        res = requests.get(
            "https://api.opentype.dev/v1/usage/ledger",
            params={"start_at": start_at, "end_at": end, "limit": 200},
            headers={"Authorization": f"Bearer {os.environ['OPENTYPE_API_KEY']}"},
            timeout=30,
        )
        if not res.ok:
            raise RuntimeError(f"{res.status_code} {res.text}")
        entries = res.json()["entries"]
        added = 0
        for e in entries:
            key = (e["run_id"], e["retry_ordinal"])
            if key not in seen:
                seen[key] = e
                added += 1
        if len(entries) < 200 or added == 0:
            return list(seen.values())
        # One second past the oldest entry, so entries sharing that second are not skipped.
        oldest = datetime.strptime(entries[-1]["created_at"], FMT)
        end = (oldest + timedelta(seconds=1)).strftime(FMT)

ledger("2026-09-01T00:00:00Z", "2026-10-01T00:00:00Z")