One request, the whole price book.

GET only, over HTTPS. CORS is open (access-control-allow-origin: *), so you can call this straight from a browser. Responses are gzipped, which is the figure that matters: the JSON is 3.0 MB of text but 93 KB over the wire. There is no pagination, no per-model endpoint and no query filtering — splitting a payload that size would only cost you requests.

Fetch it:

curl -s https://modelpricebook.com/api/v1/models

curl -sL https://modelpricebook.com/api/v1/models.csv -o model-price-book.csv

Load it into pandas and rank the cheapest sourced language models:

import pandas as pd

df = pd.read_csv("https://modelpricebook.com/api/v1/models.csv", comment="#")

# Only quote what is sourced — the rest is illustrative.
sourced = df[df.price_sourced]

# Cheapest sourced LLM by blended token price.
llm = sourced[sourced.category == "llm"].copy()
llm["blended"] = llm.price_input_per_1m + llm.price_output_per_1m
print(llm.nsmallest(5, "blended")[["name", "provider", "blended"]])

Or from JavaScript:

const res = await fetch("https://modelpricebook.com/api/v1/models");
const book = await res.json();

// Cache on snapshot_id: unchanged id means byte-identical data.
console.log(book.snapshot_id, book.model_count);

const cheapestVideo = book.models
  .filter((m) => m.category === "video" && m.price_sourced)
  .sort((a, b) => a.price_per_second - b.price_per_second)[0];

The dataset answers one question across six markets: what does this model cost, who is actually selling it, how good is it, and how do we know. Today that is 4325 priced offerings from 224 providers, 882 of 1133 tracked models carrying a sourced price and 425 carrying a sourced benchmark score.

The envelope

JSON responses wrap the rows in the terms you need to use them safely:

The columns

Every row carries 26 columns. The CSV has the same names in the same order.

• Invented numbers. Where no benchmark is published the score columns are null. Synthetic scores render on the site with an est tag and are never exported.
• Contested figures. A price its sources disagree on is not shipped as fact — it is held under review and listed on the methodology page.
• Price history. The API is a snapshot of current list prices. The history chart on the site is still an illustrative sample, so it is not exported — archive the daily snapshots yourself if you need a series.
• Negotiated or effective prices. These are provider list prices in USD, excluding taxes, batch discounts, volume tiers and context-length tiers except where price_note says otherwise. What you actually pay depends on your contract.
• Latency, throughput and rate limits. Not measured here, so not claimed here.

Why 10 is not stingy

• A complete integration costs one request. There is no pagination, no per-model endpoint and no auth round-trip: request one returns all 4325 rows, across all 6 markets, with every provenance column attached. The limit is ten times what a correct client needs.
• The data changes once a day. A daily run rebuilds the catalogue and stamps it with a new snapshot_id. Requests two through ten in the same day return byte-identical content. Polling faster cannot get you fresher numbers — it can only get you the same numbers again.
• It is a fairness device, not a paywall. There is no paid tier to upsell you to, and no key to make you register for. The limit exists so one script cannot spend the bandwidth that thousands of readers share.
• The site is one small server. This runs on a single low-cost VM in the single digits of dollars a month, with no ads, no trackers and no sponsor. Each JSON response is 93 KB on the wire, so the quota still allots every address around 928 KB a day — generous per caller, survivable in aggregate. One unbounded scraper on a loop would move more than the readers do.
• Copying is encouraged; hammering is not. The compilation is CC BY 4.0. If you need the data constantly, take it once and serve it from your own infrastructure — that is explicitly allowed, and it is better for both of us than ten thousand requests a day.

What happens when you exceed it

You get 429 Too Many Requests with a JSON body naming the limit and a Retry-After header in seconds. The window is rolling, not a midnight reset: a slot frees exactly 24 hours after it was used, so a client that backs off recovers on its own. Nothing is blocked, banned or blacklisted.

Staying under it

• Fetch once a day and cache the result. Key your cache on snapshot_id: if it has not moved, nothing in the payload has.
• Send If-None-Match with the ETag you were given. A 304 still spends a slot, but costs neither of us the payload.
• Fetch server-side, not from every visitor's browser — otherwise your users share your quota and your tenth reader gets an error.
• Do not retry a 429 immediately. Honour Retry-After; retrying in a loop just keeps the window full.

If 10 a day genuinely is not enough

Email ilyasubach@gmail.com and say what you are building. Raises are free. This matters most for shared addresses — an office, a university, a CI runner or a corporate NAT can burn ten requests between colleagues who have never met, and that is a flaw in per-IP counting rather than anything you did wrong.

The compilation is CC BY 4.0. Use it commercially, modify it, redistribute it — keep the credit. Cite as:

Model Price Book, snapshot 2026-08-03 — https://modelpricebook.com

Benchmark scores are third-party measurements used under their own attribution requirements, and that credit travels with the data: every row names its measurer in benchmark_source, and the payload's attribution object spells out the sources in full. If you republish a score, you must carry that attribution too — the methodology page explains each source's terms.

Found a wrong number? Every figure here is meant to be checked — report it and it gets fixed in public.