Methodology
The catalog is the latest verified import of models.dev, plus added providers, documented corrections and independent evaluations. This page explains how they are combined and what each label means.
Kinds of value
- models.dev Imported. Copied from models.dev and not independently checked. Imported values never carry a verification date.
- documented Documented. Set because the provider's own documentation says so. The entry names the page and the date it was read.
- measured Measured. Observed by sending requests. The entry names the access method, the client, the date and the raw result.
- API price. The list price of the API entry of the same model, shown on a subscription entry and marked "API price". It is the only value an entry takes from another one (see Prices).
A documented value and a measured one are both shown, each with its source and date. A provider documenting a 30-minute cache and an evaluation that found the cache gone after 15 minutes are two different facts, and both stay published. A measured value takes the place of a documented one in two figures only, the safe cache lifetime and the input window, and only where a measurement clearly contradicts the documentation (see Cache lifetimes and Input window); the documented figure stays beside it, and a documented limit stays in limit as imported. The other exception is an added entry, where no documented limit exists: there a measured limit is published as the limit and labelled as measured.
providers.dev takes no payment for listing, correcting or measuring an entry. A provider may supply documentation, or access for a measurement; the result is published whatever it shows. A provider can write to office@providers.dev. How to propose a value, with the evidence it needs, is on the contributing page.
Unknown values
- A missing limit is unknown. It is not zero and not unlimited, and it never matches a minimum filter.
- A missing price is unknown, not free. A missing release date is unknown too, and such an entry never matches the "Released" filter.
- For caching, models.dev distinguishes
cache = false(the entry does not cache) from nocachefield (nothing is stated). Both are kept: "None" and "Unknown". - A field can be published as explicitly unknown where the upstream value does not hold for an access method. The field is then omitted and the reason is recorded.
- Every entry page has the same sections, the same tables and the same rows, so that two entries can be read side by side. A row with no value is not left out. It says one of four things: Unknown (no source gives the value), Unsupported (a source says the entry cannot do it), Not evaluated (providers.dev has not measured it) or Not applicable (the field has no meaning for this entry). A subscription entry with no API price to refer to says In plan: there is no price per token. A list with nothing in it, such as the corrections of an entry, says None.
- The API follows the same rule. Every object providers.dev publishes has all of its fields on every entry: an unknown value is
null, never a missing field (unknown values in the API).
Limits
- Context window (
limit.context): what this provider and access method accepts for the model. It can be lower than the model's window at its lab; model pages show them side by side. - Largest input (
limit.input): stated where the input limit is lower than the window. - Maximum output (
limit.output): the most one response can hold. It is not the default a provider applies when none is requested. - Input window (
input_window): the most input one request can carry on this provider and access method, in tokens as the provider counts them. One figure per entry, documented or measured, worked out once when the data is built (see Input window). - Usable context: the window minus the system prompt and tool definitions of the client in use. That overhead varies, so no usable figure is published. The input window is not that: it is what the route accepts, the client's own prompt and tools included, not what is left after them.
- Compaction threshold: a setting of an agent or client. It is not a provider limit and is not published as one.
- Measured input: a limit evaluation sends requests of several input sizes on one access method. It records the largest input accepted, the smallest refused, and the window the route names where its answer names one; the entry page lists each evaluation with these numbers. In the catalog, ≥ before an input window marks a lower bound (
bound: at_leastin the API): the largest input seen accepted, rounded down, never up. A window listed by a client (a default the client works with) is not taken as the limit.
Input window
Every entry has one input window: the most input one request can carry on that provider and access method, in tokens as the provider counts them, the client's own system prompt and tool definitions included. It is worked out once, when the data is built, from the entry's own documented limits and its limit evaluations, and published in the API (providers_dev.limits.input_window, and input_window of a summary). The pages print it.
- Documented. Where the entry documents an input limit (
limit.input), that is the input window. Where it documents only a context window (limit.context), the window is, and the response is counted against the same figure. A 0 means none stated and is skipped. A window written onto an added entry from a measurement is a measurement, not documentation. Nothing is taken from another entry, not even from the API entry of the same model. - Contradicted. A measurement contradicts the documented figure when the route names a window below it, or names another window than a documented context window; when an input at or below 99 % of it was refused; or when an input at or above 101 % of it was accepted, below a refusal or read to the end. A window the route names is exact. The 1 % margin is for sizes: a refused size is the probe's own count, and routes add tokens of their own. Then the measured value is the input window, and the documented figure stays beside it.
- Measured. Where nothing is documented, or the documentation is contradicted, the input window is the measured one: the window the route names, or else the largest input it was seen to accept, below a refusal or read to the end. That one is a lower bound, shown as at least, and as ≥ in the catalog. Where several clients were measured, the lowest decides; each client's value is listed.
- An input accepted with nothing refused, no window named and no check that the reply read it to the end gives no value: a route can answer a request without reading all of it.
- Where nothing is documented or measured, the input window is not known and is shown as Unknown, never as 0.
On an entry's page the Input window table gives the value with its basis (documented or measured), what kind of figure it is (input alone, or input and output together), its source and date. Under it, the documented figure and the field it is in, with what the rule found of it, published as documented_status: contradicted says Documentation contradicted, not_contradicted says Documentation not contradicted, which is not the same as confirmed. Then each measurement on its own line, with its client, date and raw result. The catalog, a provider's page and a model's page show the value in an Input window column with its basis under it; the Context column shows limit.context and nothing else.
The input window has limits:
- One account per route. Another plan, region or account can have another limit.
- Dated. A provider can change a limit the next day. The date is on every value, and a measured one goes stale as all providers.dev evidence does.
- A few requests. A walk costs quota for each request that is answered, so it stops early: the real limit lies between the accepted size and the refused one, and an at least value is a lower bound by as much as that gap.
- Where no refusal was seen, nothing shows where the limit is, only that it is not below the value.
- A refused size is the probe's count, not the provider's.
- Requests were short questions with filler text and a reply of a few tokens. A window that input and output share has less room for input when a long reply is asked for.
- A window a route names is its total. A cap on the input inside it shows only as a refusal.
- The documented figure is models.dev's unless marked otherwise, and not contradicted is not confirmed.
Prices
- Prices are list prices in US dollars, as models.dev records them (
cost). They are imported, not checked. - Text is priced per million tokens. Audio, images, video and web search are charges of their own, each in the unit the source gives: per million tokens or characters, per second or minute, per image or megapixel, and per 1,000 web searches. The entry page lists them under the text charges, and the catalog shows one where an entry has no text price.
- The catalog shows the base price of text input and output, and marks an entry that has conditional rates. Those are on the entry page, one block per condition with the price of each charge: a context size ("Context above 272,000 tokens"), a service tier, a region, a date from which a price changes, or the time of day.
- Peak and off-peak hours. Some providers charge by the hour or the day of the week. The base price is the price outside the window. A rule that raises it in its window is marked Peak hours, one that lowers it Off-peak hours, with the window in UTC and the resulting prices.
- A conditional rate holds for the whole request that matches its condition: a request above a context threshold is priced at the higher rate as a whole, not only for the part above it. That is how models.dev defines its rules, and the order in which they apply: base prices, then its overrides in order, then every matching multiplier. Where a multiplier applies, the page shows the price it makes of each base price and the factor. It does not combine several conditions into one bill.
- A cache write price that differs by lifetime is shown with each lifetime.
- A price of 0 is shown as
$0. It can mean free of charge, or paid for another way (a plan or a seat): the page does not decide. - A subscription is not paid per token. So that a client can still work out what its usage is worth, every subscription entry shows the API list price of the same model, marked API price, and its page names the API entry the price is from. That is the entry a providers.dev entry was added from, or else the entry of the lab's own provider for the same canonical model. It is never what the subscription costs. Where the catalog has no API entry of that model, the entry says In plan; a price the source lists for it all the same is kept and marked Listed price. Plans and their prices are not listed.
Access methods
The same model reached with an API key and with a subscription can have different limits and cache behaviour. Each access method is a separate entry under its own provider, linked to the same model by canonical_id. An added entry takes only identity from the upstream entry it names (name, description, family, type, open_weights, knowledge, release_date, last_updated, canonical_id). Limits, caching and capabilities are never copied across access methods: on an added entry a value appears only when there is evidence for that access method. The one exception is the price: a subscription is not paid per token, so a subscription entry shows the API list price of the same model (providers_dev.pricing has billing: reference and names the API entry in reference_ref), so that a client can work out what the usage is worth.
Access is a classification: API key, subscription, or unclassified. Plans, plan prices, allowances and quotas are not tracked. API prices are kept as imported. Where a service does not disclose which underlying model it serves, the entry has no canonical_id.
Merge rules
The published dataset is computed from three separate inputs on every build. Nothing is edited in place.
- The upstream snapshot: the last import of models.dev that passed validation.
- Additions: providers and entries that models.dev does not have.
- Corrections: single fields set on upstream entries. They take precedence.
A correction is a patch applied field by field:
| In the correction | Published | Example |
|---|---|---|
| Field not mentioned | The upstream value, which keeps following upstream | Setting limit.context leaves limit.output tracking models.dev |
A value, including false and 0 | The corrected value | temperature: false is published as false, not dropped |
| An object | Merged key by key | cache: { explicit: { ttl: ["30m"] } } keeps upstream's max_breakpoints |
| An array | Replaces the upstream array | ttl: ["30m"] over ["5m", "1h"] gives ["30m"] |
null | Explicitly unknown: the field is omitted and marked unknown | limit.context: null where the upstream figure does not apply to this access method |
"$delete" | Removed: the field does not apply | limit.input: "$delete" |
exclude: true | The entry or provider is left out and listed as excluded | A provider that has shut down |
| A catalog-wide rule | Every earlier version of a model family is left out, at every provider, including those a later import brings. Listed once among the exclusions, with its reason, date and the number of entries it removed | Claude Opus versions before 5.5, an editorial choice of providers.dev |
| A rule by release date | Every entry whose release date falls in a span is left out, at every provider and of every type. An entry with no release date, or a placeholder date, is kept. Listed once among the exclusions, with its reason, date and the number of entries it removed | Models released in 2025, an editorial choice of providers.dev |
- If models.dev changes a corrected field, the correction stays. The entry's provenance shows the new upstream value next to it.
- If a correction is removed, the current upstream value is published again at the next build.
- If models.dev comes to agree with a correction, the build reports it as redundant so it can be removed.
- If the entry a correction targets disappears upstream, the correction is not applied and no entry is recreated from it. It is listed under open issues and in
/api/v1/meta. - Every correction carries a reason and at least one source with a URL and a date. A build without them fails.
The same inputs always produce the same output, and the dataset version is a hash of that output.
Daily import
Once a day a scheduled job fetches models.dev once, with a conditional request. The import is validated before it replaces anything: it must be valid JSON in the expected structure, ids must match their keys, and it must not be empty or have lost a large share of its entries since the previous import. If validation fails or models.dev is unavailable, the previous snapshot stays in place and keeps being served; the footer and /api/v1/meta report the failed import. Visitors and API requests never trigger a fetch.
The current import, source commit and counts are published at /api/v1/meta.
Documented caching
- Automatic (
implicitin the data): the provider caches the start of a prompt by itself. The request does nothing for it. - Manual (
explicit): nothing is cached unless the request marks what to cache. The mark also picks the lifetime, where there is a choice. - On an entry's page the Cache modes table has one row for each way of caching, supported or not, with its minimum prompt size, breakpoints and targets. The lifetimes the provider documents are in the Lifetimes table (see Cache lifetimes), each naming its way of caching and the text as documented (
5m, say). The request parameter and accepted values are recorded separately under Retention. - An entry can have both: it caches by itself, and a request can also mark parts. Then each has its own line.
The pages render providers_dev.cache.documented. An omitted mode remains unknown; only an explicit negative makes it unsupported.
Cache evaluations
An evaluation sends a fresh prompt once so that it is cached, then sends it again at once and at each of several set ages, a few times per age. For each age the result records how many of those re-sends were made, how many were served from the cache, and that share in percent.
Every evaluation made since 14 November 2026 follows the same ages: the prompt is sent again at once, then checked at 2.5 min, 5 min, 7.5 min, 10 min, 15 min, 20 min, 25 min, 30 min, 40 min, 50 min, 1 h, 1 h 15, 1 h 30, 2 h, 4 h, 8 h, 12 h and 24 h, the later ages where the cache lasts. "At once" is the control: it shows that the prompt was cached at all and that the route reports cache hits, so that a later miss means the cache is gone and not that nothing was cached. Older evaluations keep the ages they were made with, and some start at 5 minutes.
Results are shown per client. On an entry's page each measured lifetime in the Lifetimes table is one client and one request setting, with its results by age, and opens onto each of its evaluations with their own results. The columns are the control and the ages above. A cell is the share of re-sends at exactly that age that were served from the cache, in percent rounded to a whole number, with the hits and checks under it; the hover text has the exact percentage. Nothing is rounded into a neighbouring age: 7.5 minutes and 10 minutes are two cells. A cell with no check shows a dot; it is not a miss. A check made at an age that has no column (an older evaluation at 3 hours, say) is in the data at its exact age and is listed in words on the entry's page. The evidence page lists every evaluation, each with its percentages by age, rounded the same way.
There are two retention profiles, because a request can ask for the cache in two ways, and the two answer different questions:
- Short: the request asks for no lifetime, or for the shortest one the provider documents. This is the cache you get without asking.
- Long: the request asks for a longer lifetime, for example
cache_control.ttl=1h,prompt_cache_retention=24horprompt_cache_options.ttl=12h. Each measured lifetime shows the field and value its requests sent.
Both profiles are there on every entry. A profile with no lifetime measured says Not measured; that is not 0 %, and it says nothing about whether the provider accepts a lifetime. What a request can ask for is a separate record, Retention, on every entry's page: whether a lifetime is accepted, the request field, the accepted values and which value gives which line. It is filled from the provider's own documentation, quoted with the record: the field as a request sends it (cache_control.ttl, say), its values, and the default. Where the short lifetime is what a request gets by leaving the field out, the record says so instead of naming a value. Sending a value, receiving a cache hit, or listing several documented lifetimes is not enough to call a field supported, and nothing is copied from one provider to another: a reseller of the same model stays Unknown until its own page says it. Requested settings stay visible in evaluations even when support is unknown. The results show observed behavior, not a guaranteed lifetime.
The evaluations of one client with one request setting are added up by exact age; the results of different clients are never added together. The entry's page lists every evaluation, with its client, request settings, counts and raw result. An evaluation that checked no age and whose control hit shows that the prompt was cached and nothing about how long: it is listed under Other evaluations and is in no lifetime.
Every number on these pages is in the API as published, counts, percentages and lifetimes alike; a page formats it and works out nothing of its own. See cache evaluations in the API.
Each evaluation names the access method it was taken on and the client that sent the requests: straight to the provider, through CLIProxyAPI (an open-source proxy, and for a subscription login often the only way in besides the vendor's own tool), or through the vendor's own command-line tool. A result holds for that combination on that date. The evaluation source repository is listed in /api/v1/meta, and every evaluation links to its raw result.
Cache lifetimes
Every entry has a safe cache lifetime for each retention profile, short and long: how long a cached prompt can be relied on. It is worked out once, when the data is built, from the entry's documented lifetimes and its evaluations, and published in the API (providers_dev.cache.lifetime, and cache_lifetime of a summary). The pages print it.
- Documented. Where the provider documents a lifetime for the profile, that is the safe lifetime, unless a measurement clearly contradicts it.
- Contradicted. A measurement contradicts the documentation when one evaluation has a result at an age up to the documented lifetime, the immediate re-send included, in which fewer than half of the checks hit. Exactly half does not contradict. A miss after the documented lifetime is what the documentation says and is not looked at. Then the measured lifetime is the safe one, and the documented lifetime stays in the list.
- Measured. Where nothing is documented, the safe lifetime is the measured one: for each evaluation, the oldest age up to which every check hit, from the immediate re-send on (one miss ends it, and an older age that hits again does not raise it); then the lowest of these across evaluations and clients.
- The safe lifetime is never above the documented lifetime: a cache that still hits after it changes nothing.
- A provider that documents that it does not cache has a safe lifetime of 0, documented, shown as None. A measured 0, shown as 0 s, means no tested age at which every check hit. Where nothing is documented or measured the lifetime is not known and is shown as Unknown, never as 0.
- A measured lifetime is per client and request setting. It does not expire, and shows the date of its newest evaluation.
On an entry's page the Lifetimes table gives, for each retention profile, the safe lifetime with its basis (documented or measured), source and date; then the documented lifetime, the measured one with its number of clients, and how many checks hit inside the documented lifetime. The profile prints what the rule found, published as documented_status where a lifetime above 0 is documented and one is measured: contradicted says Documentation contradicted (the safe lifetime is the measured one), not_contradicted says Documentation not contradicted: no evaluation contradicts it, which is not the same as confirmed. Under the profile, every documented and every measured lifetime, one per line, each with its source and date. The catalog, a provider's page and a model's page show the safe lifetime of both profiles in one Cache lifetime column, with the other of the two lifetimes beside it where there is one. Lifetimes are shown in minutes and hours (5 min, 24 h); the exact seconds are in the hover text and in the API.
The safe lifetime has limits. A measurement is a sample: a few requests from one account, on some days. An age between two tested ages is not known: a cache that hit at 30 minutes and missed at 1 h 5 min may have ended at any point between. And a provider can change its cache behaviour without notice. The safe lifetime is a published number made by this rule, not a guarantee.
Dates and staleness
Every correction and evaluation has a date. Providers change cache behaviour without notice, so providers.dev evidence (a correction, an evaluation, a measured lifetime or input window) whose date is more than 90 days before today is marked stale. It stays published, with its date.
The number is stale_after_days of /api/v1/meta, set once when the data is built. The API publishes the dates and this number; a page compares a published date with today's date using it, and that is the only thing a page works out. A reader of the API applies it to its own date.
Licences and attribution are on the licensing page. How to propose a correction or a measurement is on the contributing page.