Full Example

#!/usr/bin/env python3
"""The indices you hold, one index's latest value and history, and a daily/intraday overlay."""

import os
from datetime import date, datetime, timedelta, timezone

import pandas as pd
import requests

BASE = "https://data-api.compute-index.com/v2"
HEADERS = {"Authorization": f"Bearer {os.environ['TOKEN']}"}

DAILY = "rental-h100-1y-us-daily"                  # the daily blended index for the H100, US
INTRADAY = "rental-h100-1y-us-intraday"      # the same GPU at 30-minute resolution


def walk(path: str, **params) -> list[dict]:
    """Every row across every page.

    Follow `meta.next` and send NOTHING else: the page token carries the
    filters, the resolved window and the ordering, so adding a parameter is
    rejected rather than silently ignored. `next` is null when the walk is
    done.
    """
    url, rows = f"{BASE}{path}", []
    while url:
        resp = requests.get(url, headers=HEADERS, params=params, timeout=30)
        resp.raise_for_status()
        body = resp.json()
        rows += body["data"]
        nxt = body["meta"]["next"]
        url, params = (nxt["url"], None) if nxt else (None, None)
    return rows


# Step 1: which indices does this token hold?
#
# `id` is what the data endpoints take; `row_type` says whether its rows carry
# a date (`daily`) or an instant (`intraday`) in `timestamp`.
meta = requests.get(f"{BASE}/gpu/rental/indexes/metadata", headers=HEADERS, timeout=30).json()
for index in meta["data"]["indices"]:
    print(f"{index['id']:<20} {index['index_type']:<18} {index['interval']:<6} {index['default_source']}")

# Step 2: the latest published value — one row.
latest = walk("/gpu/rental/indexes/latest", id=DAILY)[0]
print(f"\n{DAILY}: ${latest['value']:.4f}/GPU-hr on {latest['timestamp']}")

# Step 3: two years of history.
#
# `end` is exclusive, so consecutive ranges join up without returning a row
# twice. Needs historical access to this data type.
end = date.today() + timedelta(days=1)          # exclusive, so today is included
start = end - timedelta(days=730)

daily = pd.DataFrame(walk(
    "/gpu/rental/indexes/history",
    id=DAILY,
    start=start.isoformat(),
    end=end.isoformat(),
))
daily["timestamp"] = pd.to_datetime(daily["timestamp"])          # a bare date on daily rows

# Step 4: the last week at 30-minute resolution. Intraday rows carry a UTC
# instant, so bound the window with instants too.
now = datetime.now(timezone.utc)
intraday = pd.DataFrame(walk(
    "/gpu/rental/indexes/history",
    id=INTRADAY,
    start=(now - timedelta(days=7)).isoformat(),
    end=now.isoformat(),
))
intraday["timestamp"] = pd.to_datetime(intraday["timestamp"])    # a UTC instant on intraday rows

# Step 5: one frame — the daily level beside the last intraday level of each day.
last_per_day = (
    intraday.set_index("timestamp")["value"].resample("1D").last()
    .rename("intraday_close").reset_index()
)
last_per_day["timestamp"] = last_per_day["timestamp"].dt.tz_localize(None)
merged = daily[["timestamp", "value"]].rename(columns={"value": "daily"}).merge(
    last_per_day, on="timestamp", how="inner",
)

print(f"\nDaily:    {len(daily):>5} rows ({daily['timestamp'].min().date()} → {daily['timestamp'].max().date()})")
print(f"Intraday: {len(intraday):>5} rows over the last 7 days")
print(merged.tail())

# merged.plot(x="timestamp", y=["daily", "intraday_close"])  # with matplotlib

const BASE = "https://data-api.compute-index.com/v2";
const HEADERS = { Authorization: `Bearer ${process.env.TOKEN}` };

const DAILY = "rental-h100-1y-us-daily";               // the daily blended index for the H100, US
const INTRADAY = "rental-h100-1y-us-intraday";   // the same GPU at 30-minute resolution

/**
 * Every row across every page.
 *
 * Follow `meta.next` and send nothing else — the page token carries the
 * filters, the resolved window and the ordering.
 */
async function walk(path: string, params: Record<string, string>) {
  let url: string | null = `${BASE}${path}?${new URLSearchParams(params)}`;
  const rows: any[] = [];
  while (url) {
    const resp = await fetch(url, { headers: HEADERS });
    if (!resp.ok) throw new Error(`HTTP ${resp.status} on ${url}`);
    const body = await resp.json();
    rows.push(...body.data);
    url = body.meta.next?.url ?? null;
  }
  return rows;
}

// Step 1: which indices does this token hold?
const meta = await (await fetch(`${BASE}/gpu/rental/indexes/metadata`, { headers: HEADERS })).json();
for (const index of meta.data.indices) {
  console.log(`${index.id}  ${index.index_type}  ${index.interval}  ${index.default_source}`);
}

// Step 2: the latest published value — one row
const [latest] = await walk("/gpu/rental/indexes/latest", { id: DAILY });
console.log(`${DAILY}: $${latest.value.toFixed(4)}/GPU-hr on ${latest.timestamp}`);

// Step 3: two years of history. The window is half-open, so `end` is exclusive.
const end = new Date(Date.now() + 864e5).toISOString().slice(0, 10);
const start = new Date(Date.now() - 729 * 864e5).toISOString().slice(0, 10);
const daily = await walk("/gpu/rental/indexes/history", { id: DAILY, start, end });

// Step 4: the last week at 30-minute resolution — instants, not dates
const now = new Date();
const intraday = await walk("/gpu/rental/indexes/history", {
  id: INTRADAY,
  start: new Date(now.getTime() - 7 * 864e5).toISOString(),
  end: now.toISOString(),
});

// Step 5: the last intraday level of each day, beside the daily level
const intradayClose = new Map<string, number>();
for (const r of intraday) intradayClose.set(r.timestamp.slice(0, 10), r.value); // rows are oldest first
const merged = daily
  .filter((r) => intradayClose.has(r.timestamp))
  .map((r) => ({ date: r.timestamp, daily: r.value, intraday_close: intradayClose.get(r.timestamp) }));

console.log(`Daily:    ${daily.length} rows`);
console.log(`Intraday: ${intraday.length} rows over the last 7 days`);
console.table(merged.slice(-5));

# Step 1: the indices this token holds, with each one's row_type
curl -H "Authorization: Bearer $TOKEN" \
  "https://data-api.compute-index.com/v2/gpu/rental/indexes/metadata"

# Step 2: the latest value of one index — a single row
curl -H "Authorization: Bearer $TOKEN" \
  "https://data-api.compute-index.com/v2/gpu/rental/indexes/latest?id=rental-h100-1y-us-daily"

# Step 3: history over a half-open window — `end` is EXCLUSIVE
curl -H "Authorization: Bearer $TOKEN" \
  "https://data-api.compute-index.com/v2/gpu/rental/indexes/history?id=rental-h100-1y-us-daily&start=2024-09-01&end=2026-09-01"

# Step 4: follow meta.next.url verbatim for each further page, adding nothing
curl -H "Authorization: Bearer $TOKEN" \
  "https://data-api.compute-index.com/v2/gpu/rental/indexes/history?page_token=eyJ…&page_size=100"

# Step 5: the same GPU at 30-minute resolution — bound the window with instants
curl -H "Authorization: Bearer $TOKEN" \
  "https://data-api.compute-index.com/v2/gpu/rental/indexes/history?id=rental-h100-1y-us-intraday&start=2026-08-25T00:00:00Z&end=2026-09-01T00:00:00Z"