> ## 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.

# GPU Rental Prices: Metadata

> Vendor prices for renting GPU compute, in USD per GPU-hour.

Returns the values you can filter this data by, what it covers, and how far back you are able to read it, in `history_starts_at`.

This is the best first call for any data type: it tells you what a query will accept before you write one. It is not paged.

## Example

```bash theme={null}
curl -H "Authorization: Bearer $TOKEN" \
  "https://data-api.compute-index.com/v2/gpu/rental/prices/metadata?gpu_search=H100&vendor=aws"
```


## OpenAPI

````yaml pricing/openapi.json GET /v2/gpu/rental/prices/metadata
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.


    <details>

    <summary><strong>Endpoints</strong> — what the four paths
    return</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.


    </details>


    <details>

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


    Every response is `{"data": [...], "meta": {...}}`.
    `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.


    </details>


    <details>

    <summary><strong>Filtering, sorting and time</strong> — anchors,
    sort fields, UTC windows</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.


    </details>


    <details>

    <summary><strong>Access and errors</strong> — tokens, entitlements,
    rate limits</summary>


    Send a bearer token: `Authorization: Bearer <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`.


    </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/gpu/rental/prices/metadata:
    get:
      tags:
        - GPU Rental Prices
      summary: 'GPU Rental Prices: filters and coverage'
      description: >-
        Vendor prices for renting GPU compute, in USD per GPU-hour.


        Returns the values you can filter this data by, what it covers, and how
        far back you are able to read it, in `history_starts_at`.


        This is the best first call for any data type: it tells you what a query
        will accept before you write one. It is not paged.
      operationId: metadata_gpu_rental_prices_metadata_get
      responses:
        '200':
          description: Successful Response
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/MetadataEnvelope_PricesMetadata_'
        '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:
    MetadataEnvelope_PricesMetadata_:
      properties:
        data_type:
          type: string
          title: Data Type
          description: The data type this vocabulary describes.
          examples:
            - prices
        history_starts_at:
          anyOf:
            - type: string
            - type: 'null'
          title: History Starts At
          description: >-
            The caller's licensed history floor for this type, as an ISO date.
            Null means unrestricted — either the caller has no floor, or this
            type is a published series that is not floor-bound. Reported here so
            a client can discover its own entitlement in one call rather than by
            overshooting a window and reading the clamp.
          examples:
            - '2020-01-01'
        data:
          $ref: '#/components/schemas/PricesMetadata'
      additionalProperties: false
      type: object
      required:
        - data_type
        - history_starts_at
        - data
      title: MetadataEnvelope[PricesMetadata]
    PricesMetadata:
      properties:
        anchors:
          items:
            type: string
          type: array
          title: Anchors
          description: >-
            At least one of these must appear on every collection query — a
            query that asks for everything at once is rejected. `gpu_search`
            counts, because it resolves to a `gpu_canonical_name` before the
            query runs.
          examples:
            - - vendor
              - gpu_canonical_name
              - gpu_search
              - base_product_key
              - product_key
        gpus:
          items:
            $ref: '#/components/schemas/GpuVocabulary'
          type: array
          title: Gpus
          description: Every GPU with prices, current or historical.
      additionalProperties: false
      type: object
      required:
        - anchors
        - gpus
      title: PricesMetadata
      description: The `prices` vocabulary.
    GpuVocabulary:
      properties:
        gpu_canonical_name:
          type: string
          title: Gpu Canonical Name
          description: The slug to pass as an anchor.
          examples:
            - nvidia-h100-sxm5-80gb
        gpu_manufacturer:
          anyOf:
            - type: string
            - type: 'null'
          title: Gpu Manufacturer
          examples:
            - NVIDIA
        gpu_model_variants:
          anyOf:
            - items:
                type: string
              type: array
            - type: 'null'
          title: Gpu Model Variants
          description: >-
            Vendor spellings seen for this GPU, across its whole history rather
            than only its current listings — so a spelling a vendor has since
            stopped using is still here, and is still accepted by `gpu_search`.
            null when there is no spelling that can be published for this GPU.
          examples:
            - - A100
              - A100 SXM4
              - A100 NVLink
        currently_listed:
          type: boolean
          title: Currently Listed
          description: >-
            Whether any visible vendor lists this GPU today. False means history
            only: `/history` and `/as-of` can still reach it, `/latest` will
            return nothing.
        vendors:
          items:
            type: string
          type: array
          title: Vendors
          description: Visible vendors with a current listing for this GPU.
      additionalProperties: false
      type: object
      required:
        - gpu_canonical_name
        - gpu_manufacturer
        - gpu_model_variants
        - currently_listed
        - vendors
      title: GpuVocabulary
      description: One GPU this type can serve prices for.
  securitySchemes:
    HTTPBearer:
      type: http
      scheme: bearer

````