> ## Documentation Index
> Fetch the complete documentation index at: https://docs.compute-desk.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Token Prices: Latest

> LLM inference prices per model, in USD per 1M tokens.

Returns the current value for every record matching your filters — a snapshot of where things stand now, not a series over time.

<Info>
  Results are paged. Follow `meta.next` until it is `null`, and send nothing alongside it — the
  link already carries your filters, dates and ordering. See
  [Paging](/pricing/concepts#paging).
</Info>

## Example

```bash theme={null}
curl -H "Authorization: Bearer $TOKEN" \
  "https://data-api.compute-index.com/v2/llm/token/prices/latest?canonical_model_id=anthropic/claude-opus-4-8"
```


## OpenAPI

````yaml pricing/openapi.json GET /v2/llm/token/prices/latest
openapi: 3.1.0
info:
  title: GPU Pricing API (v2)
  description: >

    Pricing data for GPU compute — rental and purchase prices, settled

    transactions, published indices, and LLM inference prices.


    Every data type exposes the same four endpoints over one filter vocabulary,

    one response envelope and one error format, so learning one is learning all
    of

    them. **Start at `/metadata`**, which lists the values a type accepts and
    the

    range it holds.


    &lt;details>

    &lt;summary>&lt;strong>Endpoints&lt;/strong> — what the four paths
    return&lt;/summary>


    | path | returns |

    | --- | --- |

    | `/latest` | the current state, one row per thing |

    | `/as-of` | the state as it stood on a given date |

    | `/history` | rows over a time window |

    | `/metadata` | the type's own vocabulary — the valid filter values, and
    what it covers |


    Some types have fewer. Settled transactions are events, and "the current
    state

    of events" is not a question, so those types serve `/history` and
    `/metadata`

    and nothing else.


    &lt;/details>


    &lt;details>

    &lt;summary>&lt;strong>Responses and paging&lt;/strong> — the envelope, and
    how to get page two&lt;/summary>


    Every response is `&#123;"data": [...], "meta": &#123;...&#125;&#125;`.
    `data` is the rows; `meta`

    describes the request they answer — the sort applied, the window resolved,
    and

    the paging position.


    Nulls are always present. A null means the value is not published, which is

    different from zero and different from absent.


    `page_size` sets the rows per page (default 100, max 1000). Follow
    `meta.next`

    for the following page, and stop when it is null.


    `meta.next` is an object describing the following page three ways: `url` is
    an

    absolute URL ready to call, and `path` plus `query_params` are the same
    request

    split up for clients that build their own. Use whichever suits your HTTP
    layer.


    Each carries a `page_token`, and the token IS the request — it replays your

    filters, window and sort exactly — so a following page cannot silently
    change

    the question. There is nothing to merge in and nothing to add: do not
    construct

    or edit a token, and send no parameters beside it. There is no offset, and
    no

    total count.


    &lt;/details>


    &lt;details>

    &lt;summary>&lt;strong>Filtering, sorting and time&lt;/strong> — anchors,
    sort fields, UTC windows&lt;/summary>


    Filters are per type and listed on each operation. Values are exact matches

    unless the parameter says otherwise, and where a list is accepted it is

    comma-separated.


    **Some types require an anchor** — at least one filter that narrows the
    query,

    such as a vendor or a GPU. Asking for everything at once is rejected with a

    clear error naming the fields that qualify, and `/metadata` lists them.


    `sort_by` and `sort_order` control ordering, from that type's own set of

    sortable fields; `meta.sort` reports what was applied.


    All timestamps are UTC, ISO-8601. Windows are `start`/`end` and are
    half-open

    — `start` is included, `end` is not — so consecutive windows tile without

    double-counting a boundary row.


    &lt;/details>


    &lt;details>

    &lt;summary>&lt;strong>Access and errors&lt;/strong> — tokens, entitlements,
    rate limits&lt;/summary>


    Send a bearer token: `Authorization: Bearer &lt;token>`. Entitlements are
    per

    data type, so a token reaches the types it is granted and 403s on the rest.

    Rate limits are reported on every response in the `X-RateLimit-*` headers.


    Errors are RFC 9457 problem details, served as `application/problem+json`
    with

    `type`, `title`, `status` and `detail`.


    &lt;/details>
  contact:
    name: API Support
    email: david@compute-index.com
  version: 2.0.0
servers:
  - url: https://data-api.compute-index.com
security: []
tags:
  - name: GPU Rental Prices
    description: >-
      What it costs to rent GPU compute, as listed by the vendors themselves.
      One row is one vendor's price for one product.


      Prices are normalised so they compare across vendors: read
      `price_usd_per_gpu_hour`. `raw_price` and `raw_price_unit` keep whatever
      the vendor actually published, for when you need the original.


      A price that changes produces a new row rather than editing the old one,
      so `/history` reads as a list of changes and `/as-of` as a single state.


      Collection queries need an anchor — a vendor, a GPU, or another narrowing
      filter. `/metadata` lists which fields qualify here.
  - name: GPU Rental Aggregated Transactions
    description: >-
      Settled GPU deals published as blends rather than individually. Every row
      is a volume-weighted blend of at least two deals, so no single deal can be
      identified from it.


      `price` is the only price figure on a row: there is no median, range or
      spread to ask for.


      **Do not sum across rows.** Some rows share a deal with the row before
      them, so adding up `total_gpu_count` or `total_gpu_hours` will
      double-count. `is_rolling` marks those rows, and `blend_axis` names what
      was combined to make up the row.


      There is no `/latest` or `/as-of` — use `/history` with a window.
  - name: GPU Price Indexes
    description: >-
      Published GPU price indices — blended transaction indices at daily and
      30-minute resolution, by GPU family or by GPU, per region — and the GPU
      reference price, the fleet-weighted mean of the per-GPU indices.


      **One index per request.** Every data endpoint takes a required `id`;
      `/metadata` lists the ids you hold, and an id you do not hold returns 404.


      **Two row shapes, told apart by `type`.** A `daily` row's `timestamp` is a
      calendar date (`2026-09-02`); an `intraday` row's is the UTC instant its
      interval starts (`2026-09-02T10:00:00+00:00`). `/metadata` gives each
      index's `row_type`, so you know the shape before you ask. Sort by
      `timestamp` or `value`.


      `/metadata` says who computes each index. `p5` and `p95` bracket `value`
      where an envelope is published, and are null where it is not.
  - name: GPU Hardware Prices
    description: >-
      What it costs to buy GPU hardware outright, from resale, marketplace and
      reseller listings — the capex counterpart to rental prices. One row is one
      listing on one day it was seen.


      A listing that was not seen on a given day has no row for that day, so
      `/latest` returns each listing's most recent observation rather than a
      single snapshot. Check `last_observed` in `/metadata` before reading a
      product's price as current.


      **Seller identity is not published** — no platform, seller or listing URL,
      and none of them filterable. What you get instead is the classification a
      price needs to be read correctly: `market`, `channel`, `price_type`,
      `source_type`, `confidence` and `counterparty_class`. Check the
      `includes_*` fields too — a whole-chassis price and a bare-module price
      are not the same number.
  - name: LLM Token Prices
    description: >-
      Published prices for LLM inference, normalised to USD per 1M tokens so
      they compare across sources that quote per-token, per-1k and per-1M.


      **One model has many rows.** A row is identified by the whole combination
      of source, model, serving provider, price type, region, metric and
      qualifiers — input and output are priced separately, and the same model
      appears once per source and once per provider. Filtering to a model and
      expecting a single row will not work.


      Implausible prices are flagged rather than removed: `is_price_outlier`
      marks them and they are included by default, so a response is the data as
      recorded. Pass `exclude_outliers=true` to drop them.
paths:
  /v2/llm/token/prices/latest:
    get:
      tags:
        - LLM Token Prices
      summary: Current LLM Token Prices
      description: >-
        LLM inference prices per model, in USD per 1M tokens.


        Returns the current value for every record matching your filters — a
        snapshot of where things stand now, not a series over time.
      operationId: latest_llm_token_prices_latest_get
      parameters:
        - name: canonical_model_id
          in: query
          required: false
          schema:
            anyOf:
              - type: string
              - type: 'null'
            description: >-
              Canonical model id, exact match — `&lt;lab>/&lt;family>` as
              resolved from the model catalog. Comma-separated list accepted
              (max 20). Values are listed by this data type's `/metadata`.
            examples:
              - anthropic/claude-opus-4-8
            title: Canonical Model Id
          description: >-
            Canonical model id, exact match — `&lt;lab>/&lt;family>` as resolved
            from the model catalog. Comma-separated list accepted (max 20).
            Values are listed by this data type's `/metadata`.
        - name: base_product_key
          in: query
          required: false
          schema:
            anyOf:
              - type: string
              - type: 'null'
            description: >-
              Identity hash: every observation of one priced thing over time,
              across price changes. Obtain it from a previous response — it is
              the natural anchor for history drill-down.
            title: Base Product Key
          description: >-
            Identity hash: every observation of one priced thing over time,
            across price changes. Obtain it from a previous response — it is the
            natural anchor for history drill-down.
        - name: product_key
          in: query
          required: false
          schema:
            anyOf:
              - type: string
              - type: 'null'
            description: >-
              Snapshot identity hash: one exact observation (identity + time +
              price).
            title: Product Key
          description: >-
            Snapshot identity hash: one exact observation (identity + time +
            price).
        - name: lab
          in: query
          required: false
          schema:
            anyOf:
              - type: string
              - type: 'null'
            description: >-
              Model creator, exact match (lower-case). Comma-separated list
              accepted (max 20). A refinement, not an anchor: pair it with a
              model id, or list models from `/metadata`.
            examples:
              - anthropic
            title: Lab
          description: >-
            Model creator, exact match (lower-case). Comma-separated list
            accepted (max 20). A refinement, not an anchor: pair it with a model
            id, or list models from `/metadata`.
        - name: metric
          in: query
          required: false
          schema:
            anyOf:
              - type: string
              - type: 'null'
            description: >-
              What is priced, exact match. Comma-separated list accepted (max
              20). Example: `input_text_token,output_text_token`
            examples:
              - output_text_token
            title: Metric
          description: >-
            What is priced, exact match. Comma-separated list accepted (max 20).
            Example: `input_text_token,output_text_token`
        - name: source
          in: query
          required: false
          schema:
            anyOf:
              - type: string
              - type: 'null'
            description: >-
              Aggregator the price was read from, exact match. Comma-separated
              list accepted. One of `openrouter`, `litellm`, `models_dev`,
              `artificial_analysis`.
            title: Source
          description: >-
            Aggregator the price was read from, exact match. Comma-separated
            list accepted. One of `openrouter`, `litellm`, `models_dev`,
            `artificial_analysis`.
        - name: price_type
          in: query
          required: false
          schema:
            anyOf:
              - type: string
              - type: 'null'
            description: >-
              Kind of price, exact match: `list` (a provider's published
              catalogue), `marketplace` (a marketplace's own rate), `measured`
              (observed by a third-party evaluator). Comma-separated list
              accepted.
            title: Price Type
          description: >-
            Kind of price, exact match: `list` (a provider's published
            catalogue), `marketplace` (a marketplace's own rate), `measured`
            (observed by a third-party evaluator). Comma-separated list
            accepted.
        - name: provider
          in: query
          required: false
          schema:
            anyOf:
              - type: string
              - type: 'null'
            description: >-
              Serving host, exact match (lower-case). Comma-separated list
              accepted. Null on rows from a marketplace or a measurement rather
              than a named host.
            title: Provider
          description: >-
            Serving host, exact match (lower-case). Comma-separated list
            accepted. Null on rows from a marketplace or a measurement rather
            than a named host.
        - name: modality
          in: query
          required: false
          schema:
            anyOf:
              - type: string
              - type: 'null'
            description: >-
              Model modality, exact match. Comma-separated list accepted.
              Example: `text,multimodal`
            title: Modality
          description: >-
            Model modality, exact match. Comma-separated list accepted. Example:
            `text,multimodal`
        - name: min_price_per_mtok
          in: query
          required: false
          schema:
            anyOf:
              - type: number
                minimum: 0
              - type: 'null'
            description: Only rows priced at >= this many USD/1M tokens (inclusive).
            title: Min Price Per Mtok
          description: Only rows priced at >= this many USD/1M tokens (inclusive).
        - name: max_price_per_mtok
          in: query
          required: false
          schema:
            anyOf:
              - type: number
                minimum: 0
              - type: 'null'
            description: Only rows priced at <= this many USD/1M tokens (inclusive).
            title: Max Price Per Mtok
          description: Only rows priced at <= this many USD/1M tokens (inclusive).
        - name: exclude_outliers
          in: query
          required: false
          schema:
            type: boolean
            description: >-
              Drop rows flagged `is_price_outlier` (>20x the cross-source median
              for the same model, metric and unit — in practice a source unit
              error). Default false: the data is served as recorded, with the
              flag on every row.
            default: false
            title: Exclude Outliers
          description: >-
            Drop rows flagged `is_price_outlier` (>20x the cross-source median
            for the same model, metric and unit — in practice a source unit
            error). Default false: the data is served as recorded, with the flag
            on every row.
        - name: sort_by
          in: query
          required: false
          schema:
            anyOf:
              - type: string
              - type: 'null'
            description: >-
              Sort field. One of: canonical_model_id, metric, price_per_mtok,
              source, valid_from. Default: `canonical_model_id`.
            title: Sort By
          description: >-
            Sort field. One of: canonical_model_id, metric, price_per_mtok,
            source, valid_from. Default: `canonical_model_id`.
        - name: sort_order
          in: query
          required: false
          schema:
            anyOf:
              - type: string
              - type: 'null'
            description: 'Sort direction: `asc` or `desc`. Default: `asc`.'
            title: Sort Order
          description: 'Sort direction: `asc` or `desc`. Default: `asc`.'
        - name: page_size
          in: query
          required: false
          schema:
            type: integer
            maximum: 1000
            minimum: 1
            description: Rows per page (max 1000).
            default: 100
            title: Page Size
          description: Rows per page (max 1000).
        - name: page_token
          in: query
          required: false
          schema:
            anyOf:
              - type: string
              - type: 'null'
            description: >-
              Opaque token token from a previous response's `meta.next`. It
              carries the whole request — filters, ordering, window and position
              — so supply it alone; the only parameter that may accompany it is
              `page_size`. Do not construct or parse these; the format is not
              part of the contract.
            title: Page Token
          description: >-
            Opaque token token from a previous response's `meta.next`. It
            carries the whole request — filters, ordering, window and position —
            so supply it alone; the only parameter that may accompany it is
            `page_size`. Do not construct or parse these; the format is not part
            of the contract.
      responses:
        '200':
          description: Successful Response
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Page_TokenPriceRow_PageMeta_'
        '401':
          description: Unauthorized — `code` is `unauthenticated`.
          content:
            application/problem+json:
              example:
                status: 401
                title: Unauthorized
                detail: Missing or invalid bearer token.
                code: unauthenticated
                request_id: 01JQ2X8N4T6V9WZ0ABCD
        '403':
          description: Forbidden — `code` is `insufficient_entitlement`.
          content:
            application/problem+json:
              example:
                status: 403
                title: Forbidden
                detail: The token does not carry the scopes this endpoint requires.
                code: insufficient_entitlement
                request_id: 01JQ2X8N4T6V9WZ0ABCD
        '404':
          description: Not Found — `code` is `not_found`.
          content:
            application/problem+json:
              example:
                status: 404
                title: Not Found
                detail: No such resource, or none you are entitled to see.
                code: not_found
                request_id: 01JQ2X8N4T6V9WZ0ABCD
        '422':
          description: Unprocessable Content — `code` is `validation_failed`.
          content:
            application/problem+json:
              example:
                status: 422
                title: Unprocessable Content
                detail: A parameter failed validation.
                code: validation_failed
                request_id: 01JQ2X8N4T6V9WZ0ABCD
        '429':
          description: Too Many Requests — `code` is `rate_limited`.
          content:
            application/problem+json:
              example:
                status: 429
                title: Too Many Requests
                detail: Rate limit exceeded; see the X-RateLimit-* headers.
                code: rate_limited
                request_id: 01JQ2X8N4T6V9WZ0ABCD
      security:
        - HTTPBearer: []
components:
  schemas:
    Page_TokenPriceRow_PageMeta_:
      properties:
        data:
          items:
            $ref: '#/components/schemas/TokenPriceRow'
          type: array
          title: Data
          description: The rows in this page, ordered as `meta.sort` reports.
        meta:
          $ref: '#/components/schemas/PageMeta'
      additionalProperties: false
      type: object
      required:
        - data
        - meta
      title: Page[TokenPriceRow, PageMeta]
    TokenPriceRow:
      properties:
        canonical_model_id:
          anyOf:
            - type: string
            - type: 'null'
          title: Canonical Model Id
          description: The normalised model identifier, and the anchor to query by.
          examples:
            - anthropic/claude-opus-4-8
        lab:
          anyOf:
            - type: string
            - type: 'null'
          title: Lab
          description: Who trained the model.
          examples:
            - anthropic
        modality:
          anyOf:
            - type: string
            - type: 'null'
          title: Modality
          examples:
            - text
        is_open_weight:
          anyOf:
            - type: boolean
            - type: 'null'
          title: Is Open Weight
          description: Whether the weights are published.
        context_length:
          anyOf:
            - type: integer
            - type: 'null'
          title: Context Length
          description: Context window in tokens.
          examples:
            - 200000
        tokenizer:
          anyOf:
            - type: string
            - type: 'null'
          title: Tokenizer
          description: The tokenizer the price is denominated against.
        metric:
          anyOf:
            - type: string
            - type: 'null'
          title: Metric
          description: What is priced — input, output, cache read. A model has several.
          examples:
            - output_text_token
        price_type:
          anyOf:
            - type: string
            - type: 'null'
          title: Price Type
          description: List, promotional, batch, and similar.
          examples:
            - list
        source:
          anyOf:
            - type: string
            - type: 'null'
          title: Source
          description: Where the price was collected from.
          examples:
            - litellm
        source_model_id:
          anyOf:
            - type: string
            - type: 'null'
          title: Source Model Id
          description: The model id as that source names it.
        provider:
          anyOf:
            - type: string
            - type: 'null'
          title: Provider
          description: Who serves the model, which may not be the lab.
        region:
          anyOf:
            - type: string
            - type: 'null'
          title: Region
          examples:
            - global
        qualifiers:
          anyOf:
            - additionalProperties: true
              type: object
            - type: 'null'
          title: Qualifiers
          description: Tier or condition this price applies under; open-ended by source.
          examples:
            - {}
        price_per_mtok:
          anyOf:
            - type: number
            - type: 'null'
          title: Price Per Mtok
          description: >-
            The normalised price: USD per 1M tokens, comparable across sources
            whatever unit they publish. Zero is a real price — some tiers are
            free — not a missing value.
          examples:
            - 75
        raw_price:
          anyOf:
            - type: number
            - type: 'null'
          title: Raw Price
          description: The price as the source published it.
        raw_price_unit:
          anyOf:
            - type: string
            - type: 'null'
          title: Raw Price Unit
          description: The unit `raw_price` is in.
          examples:
            - USD/token
        is_price_outlier:
          anyOf:
            - type: boolean
            - type: 'null'
          title: Is Price Outlier
          description: >-
            Flagged, not dropped: a per-token figure published as per-Mtok is
            1e6 out, and this marks it. Such rows are included by default, so a
            response is the data as recorded rather than a filtered view of it;
            pass `exclude_outliers=true` to exclude them.
        valid_from:
          anyOf:
            - type: string
            - type: 'null'
          title: Valid From
          description: Inclusive start of the interval, UTC instant.
        valid_to:
          anyOf:
            - type: string
            - type: 'null'
          title: Valid To
          description: Exclusive end; null means not yet superseded.
        extracted_at:
          anyOf:
            - type: string
            - type: 'null'
          title: Extracted At
          description: When this snapshot was captured. Not a validity bound.
        base_product_key:
          anyOf:
            - type: string
            - type: 'null'
          title: Base Product Key
          description: Hash identifying this line across its price changes.
        product_key:
          anyOf:
            - type: string
            - type: 'null'
          title: Product Key
          description: Hash identifying this one immutable row.
      additionalProperties: false
      type: object
      required:
        - canonical_model_id
        - lab
        - modality
        - is_open_weight
        - context_length
        - tokenizer
        - metric
        - price_type
        - source
        - source_model_id
        - provider
        - region
        - qualifiers
        - price_per_mtok
        - raw_price
        - raw_price_unit
        - is_price_outlier
        - valid_from
        - valid_to
        - extracted_at
        - base_product_key
        - product_key
      title: TokenPriceRow
      description: >-
        One priced line of one model, over one validity interval.


        TALL: identity is the whole tuple of (source, model, provider,
        price_type,

        region, metric, qualifiers), so a single model carries many rows — input

        and output priced separately, per source, per serving provider, per

        qualifier tier. Filtering to one model and expecting one row is the

        commonest way to misread this type.
    PageMeta:
      properties:
        page_size:
          type: integer
          title: Page Size
          description: Rows requested per page.
          examples:
            - 100
        returned:
          type: integer
          title: Returned
          description: Rows in this page, which is `page_size` or fewer.
          examples:
            - 100
        has_more:
          type: boolean
          title: Has More
          description: Whether a further page exists.
        next:
          anyOf:
            - $ref: '#/components/schemas/NextPage'
            - type: 'null'
          description: >-
            How to fetch the following page, or null at the end of the walk. Use
            it exactly as given: it locks in every defaulted parameter — the
            window and the resolved ordering in particular — so later pages
            cannot drift against earlier ones. There is no `offset`, and nothing
            may be added to the request it describes.
        sort:
          $ref: '#/components/schemas/SortMeta'
      additionalProperties: false
      type: object
      required:
        - page_size
        - returned
        - has_more
        - next
        - sort
      title: PageMeta
      description: >-
        What every collection endpoint reports about the page itself.


        There is no total count. `has_more` tells you whether to fetch another
        page.
    NextPage:
      properties:
        path:
          type: string
          title: Path
          description: Path to call, without an origin.
          examples:
            - /v2/gpu/rental/prices/history
        query_params:
          additionalProperties:
            type: string
          type: object
          title: Query Params
          description: >-
            The query parameters to send, unencoded. Always exactly the token
            and the page size — the token carries every filter, the window and
            the ordering, so nothing else may accompany it.
          examples:
            - page_size: '100'
              page_token: eyJkIjoicHJpY2VzIiwiZSI6Imhpc3RvcnkiLC4uLg.qgLm5w
        url:
          type: string
          title: Url
          description: The same request as an absolute URL, ready to call.
          examples:
            - >-
              https://data-api.compute-index.com/v2/gpu/rental/prices/history?page_token=eyJkIjoicHJpY2VzIiwiZSI6Imhpc3RvcnksLi4u.qgLm5w&page_size=100
      additionalProperties: false
      type: object
      required:
        - path
        - query_params
        - url
      title: NextPage
      description: >-
        Where to get the following page, given three ways.


        All three describe the same request, so use whichever suits your HTTP

        layer: `url` to call directly, `path` if you already hold a base URL,
        and

        `query_params` if you pass parameters as a mapping rather than building
        a

        query string.


        There is nothing to merge in and nothing to add: the page token carries
        the

        whole request — every filter, the window and the ordering — so this is
        the

        complete next call.
    SortMeta:
      properties:
        by:
          type: string
          title: By
          description: The field the rows are ordered by.
          examples:
            - valid_from
        order:
          type: string
          title: Order
          description: '`asc` or `desc`.'
          examples:
            - desc
      additionalProperties: false
      type: object
      required:
        - by
        - order
      title: SortMeta
      description: |-
        The ordering actually applied, echoed so a caller who sent no sort
        parameters can read what they got instead of inferring it from the docs.
  securitySchemes:
    HTTPBearer:
      type: http
      scheme: bearer

````