Admin API reference (v1)

curl -sS "https://app.curobi.com/api/admin/v1/subscriptions?status=ACTIVE&limit=100" \
  -H "Authorization: Bearer $CUROBI_API_KEY" | jq '.data | length'

const url = new URL("https://app.curobi.com/api/admin/v1/subscriptions");
url.searchParams.set("status", "ACTIVE");
url.searchParams.set("limit", "100");
 
const res = await fetch(url, {
  headers: { Authorization: `Bearer ${CUROBI_API_KEY}` },
});
const { data } = await res.json();
 
console.log(data.length);

import { curobi } from "./curobi.js";
 
const { data } = await curobi("/subscriptions", {
  params: { status: "ACTIVE", limit: 100 },
});
 
console.log(data.length);

res = session.get(f"{BASE}/subscriptions", params={"status": "ACTIVE", "limit": 100})
res.raise_for_status()
 
print(len(res.json()["data"]))

def get(path, **params)
  uri = URI("#{BASE}#{path}")
  uri.query = URI.encode_www_form(params.compact)
 
  req = Net::HTTP::Get.new(uri)
  req["Authorization"] = "Bearer #{ENV.fetch('CUROBI_API_KEY')}"
 
  res = Net::HTTP.start(uri.host, uri.port, use_ssl: true) { |http| http.request(req) }
  body = JSON.parse(res.body)
  raise "#{body.dig('error', 'code')}" unless res.is_a?(Net::HTTPSuccess)
 
  body
end
 
puts get("/subscriptions", status: "ACTIVE", limit: 100)["data"].length

import type { Route } from "./+types/dashboard";
 
export async function loader() {
  const url = new URL("https://app.curobi.com/api/admin/v1/subscriptions");
  url.searchParams.set("status", "ACTIVE");
  url.searchParams.set("limit", "100");
 
  const res = await fetch(url, {
    headers: { Authorization: `Bearer ${process.env.CUROBI_API_KEY}` },
  });
  const { data } = await res.json();
 
  return { activeCount: data.length };
}
 
export default function Dashboard({ loaderData }: Route.ComponentProps) {
  return <h1>{loaderData.activeCount} active</h1>;
}

cursor=""
while :; do
  page=$(curl -sS "https://app.curobi.com/api/admin/v1/subscriptions?limit=250&cursor=$cursor" \
    -H "Authorization: Bearer $CUROBI_API_KEY")
  echo "$page" | jq -c '.data[]'
  cursor=$(echo "$page" | jq -r '.next_cursor // empty')
  [ -z "$cursor" ] && break
done

async function* paginate(path, params = {}) {
  let cursor = null;
 
  do {
    const url = new URL(`https://app.curobi.com/api/admin/v1${path}`);
    for (const [key, value] of Object.entries({ ...params, limit: 250 })) {
      url.searchParams.set(key, String(value));
    }
    if (cursor) url.searchParams.set("cursor", cursor);
 
    const res = await fetch(url, {
      headers: { Authorization: `Bearer ${CUROBI_API_KEY}` },
    });
    if (!res.ok) throw new Error((await res.json()).error.code);
 
    const page = await res.json();
    yield* page.data;
    cursor = page.next_cursor;
  } while (cursor);
}
 
for await (const contract of paginate("/subscriptions", { status: "ACTIVE" })) {
  console.log(contract.contract_id, contract.status);
}

import { curobi } from "./curobi.js";
 
// An async generator, so the caller streams rows instead of buffering the whole
// crawl — a large shop's subscription list does not want to be one array.
export async function* paginate(path, params = {}) {
  let cursor = null;
 
  do {
    const page = await curobi(path, { params: { ...params, limit: 250, cursor } });
    yield* page.data;
    cursor = page.next_cursor;
  } while (cursor);
}

import { paginate } from "./paginate.js";
 
for await (const contract of paginate("/subscriptions", { status: "ACTIVE" })) {
  console.log(contract.contract_id, contract.status);
}

def paginate(path, **params):
    cursor = None
 
    while True:
        # requests drops `None` params, so the first call simply omits `cursor`.
        query = {**params, "limit": 250, "cursor": cursor}
 
        res = session.get(f"{BASE}{path}", params=query)
        res.raise_for_status()
 
        body = res.json()
        yield from body["data"]
 
        cursor = body["next_cursor"]
        if cursor is None:
            break
 
 
for contract in paginate("/subscriptions", status="ACTIVE"):
    print(contract["contract_id"], contract["status"])

def paginate(path, **params)
  return enum_for(:paginate, path, **params) unless block_given?
 
  cursor = nil
  loop do
    page = get(path, **params, limit: 250, cursor: cursor)
    page["data"].each { |row| yield row }
 
    cursor = page["next_cursor"]
    break if cursor.nil?
  end
end
 
paginate("/subscriptions", status: "ACTIVE").each do |contract|
  puts "#{contract['contract_id']} #{contract['status']}"
end

// A resource route — no default export, so it returns data rather than UI.
const BASE = "https://app.curobi.com/api/admin/v1";
 
type Page = { data: unknown[]; next_cursor: string | null };
 
async function fetchPage(cursor?: string): Promise<Page> {
  const url = new URL(`${BASE}/subscriptions`);
  url.searchParams.set("limit", "250");
  if (cursor) url.searchParams.set("cursor", cursor);
 
  const res = await fetch(url, {
    headers: { Authorization: `Bearer ${process.env.CUROBI_API_KEY}` },
  });
  if (!res.ok) throw new Response("Curobi API error", { status: res.status });
 
  return res.json();
}
 
export async function loader() {
  const all: unknown[] = [];
  let cursor: string | null = null;
 
  do {
    const page = await fetchPage(cursor ?? undefined);
    all.push(...page.data);
    cursor = page.next_cursor;
  } while (cursor);
 
  return Response.json(all);
}

curl -sS "https://app.curobi.com/api/admin/v1/subscriptions?updated_after=2026-08-15T00:00:00Z&limit=250" \
  -H "Authorization: Bearer $CUROBI_API_KEY"

// Read the watermark first: if the run dies halfway, the next one repeats the
// window rather than skipping it. Upserts make the overlap harmless.
const since = await readWatermark();      // e.g. "2026-08-15T00:00:00Z"
const startedAt = new Date().toISOString();
 
for await (const contract of paginate("/subscriptions", { updated_after: since })) {
  await upsert(contract);
}
 
await writeWatermark(startedAt);

import { paginate } from "./paginate.js";
 
const since = await readWatermark();      // e.g. "2026-08-15T00:00:00Z"
const startedAt = new Date().toISOString();
 
for await (const contract of paginate("/subscriptions", { updated_after: since })) {
  await upsert(contract);
}
 
// Advance only after the crawl finished, and stamp it from the *start* of the
// run so rows written mid-crawl are picked up next time instead of being lost.
await writeWatermark(startedAt);

from datetime import datetime, timezone
 
since = read_watermark()  # e.g. "2026-08-15T00:00:00Z"
started_at = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
 
for contract in paginate("/subscriptions", updated_after=since):
    upsert(contract)
 
write_watermark(started_at)

require "time"
 
since      = read_watermark  # e.g. "2026-08-15T00:00:00Z"
started_at = Time.now.utc.iso8601
 
paginate("/subscriptions", updated_after: since).each { |contract| upsert(contract) }
 
write_watermark(started_at)

// Hit this from a scheduler. Guard it — a resource route is a public URL.
import type { Route } from "./+types/api.sync";
 
export async function action({ request }: Route.ActionArgs) {
  if (request.headers.get("Authorization") !== `Bearer ${process.env.CRON_SECRET}`) {
    throw new Response("Unauthorized", { status: 401 });
  }
 
  const since = await readWatermark();
  const startedAt = new Date().toISOString();
 
  const url = new URL("https://app.curobi.com/api/admin/v1/subscriptions");
  url.searchParams.set("updated_after", since);
  url.searchParams.set("limit", "250");
 
  const res = await fetch(url, {
    headers: { Authorization: `Bearer ${process.env.CUROBI_API_KEY}` },
  });
  const { data } = await res.json();
 
  for (const contract of data) await upsert(contract);
  await writeWatermark(startedAt);
 
  return Response.json({ synced: data.length });
}