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

# GET /v1/prices — CS2 minAsk Price List by Item Group

> Retrieve a paginated minAsk price snapshot grouped by market hash name, wear, and Doppler phase, with cheapest ask and listing count per row.

The prices endpoint returns a grouped price snapshot of the CSBoard marketplace. Each row represents a unique combination of `market_hash_name`, `wear`, and `doppler_phase`, and carries the cheapest current asking price together with how many copies are listed. This makes it efficient for building price comparison tables, alerting pipelines, or portfolio valuation — you can retrieve pricing for thousands of items without pulling individual listings.

**Authentication required.** Send your key as `Authorization: Bearer csb_pub_...`.

> [!NOTE]
>
> Pass `appId=570` for Dota 2 or `appId=252490` for Rust. For those games each row is one `market_hash_name`, with `wear` and `doppler_phase` set to `null`. See [Games](https://api.csboard.com/api-reference/get-games.md). Only need one number per name? [`GET /v1/public/prices`](https://api.csboard.com/api-reference/get-public-prices) works without a key.

## Query parameters

**appId** `integer` (default: 730)

Game to read: `730` = CS2, `570` = Dota 2, `252490` = Rust. Omit it for CS2. See [`GET /v1/games`](https://api.csboard.com/api-reference/get-games) for the games your key can use.

**search** `string`

Fuzzy match on `market_hash_name` — splits the query into words and substring-matches each. A name that is a word-subset of a longer item's name (e.g. `Spectrum Case` vs `Spectrum 2 Case`) cannot be isolated this way; use `name` for an exact lookup.

**name** `string`

Exact `market_hash_name` (case-insensitive) — the precise single-item lookup. `name=Spectrum Case` returns only the Spectrum Case group, never `Spectrum 2 Case`. Takes precedence over `search`.

**category** `string`

Filter by item category, e.g. `Rifle`, `Knife`, `Gloves`.

**wear** `string`

Filter by wear bucket. One of: `Factory New`, `Minimal Wear`, `Field-Tested`, `Well-Worn`, `Battle-Scarred`. CS2 only — with another `appId` it answers `400 invalid_param`.

**rarity** `string`

Filter by rarity tier, e.g. `Classified`, `Covert`.

**min\_price** `number`

Minimum `min_price_usd` in USD (inclusive).

**max\_price** `number`

Maximum `min_price_usd` in USD (inclusive).

**cursor** `string`

Keyset pagination cursor. Pass the `next_cursor` value from the previous response.

**limit** `integer` (default: 100)

Number of rows per page. Minimum `1`, maximum `500`.

## Response fields

**items** `PriceRow[]` *required*

Array of price rows for this page.

**PriceRow object**

**market\_hash\_name** `string` *required*

Steam market hash name, e.g. `AK-47 | Redline (Field-Tested)`.

**wear** `string | null`

Wear bucket for this price group. `null` for items without a wear tier.

**doppler\_phase** `string | null`

Doppler or Gamma Doppler phase for this price group, e.g. `"Phase 2"`, `"Ruby"`. `null` for non-Doppler items.

**min\_price\_usd** `number` *required*

Cheapest current asking price in USD across all listings in this group.

**qty** `integer` *required*

Number of listings currently available in this group.

**next\_cursor** `string | null` *required*

Keyset cursor for the next page. Pass as `cursor` on the next request. `null` on the last page.

## Example request

```bash theme={null}
curl "https://csboard.com/v1/prices?category=Rifle&wear=Field-Tested&limit=50" \
  -H "Authorization: Bearer csb_pub_..."
```

## Example response

```json theme={null}
{
  "items": [
    {
      "market_hash_name": "AK-47 | Redline (Field-Tested)",
      "wear": "Field-Tested",
      "doppler_phase": null,
      "min_price_usd": 11.92,
      "qty": 73
    }
  ],
  "next_cursor": null
}
```

## Error codes

| HTTP status | Code | Meaning |
| - | - | - |
| 400 | `invalid_param` | `wear` sent with a Dota 2 or Rust `appId`. |
| 400 | `unsupported_game` | Your key cannot use this `appId`. `supported_app_ids` lists the ones it can. |
| 401 | `missing_api_key`, `invalid_api_key` | Missing or invalid API key. |
| 429 | `rate_limit_exceeded` | Over your key's read limit (100/min by default). Wait for the `Retry-After` header value before retrying. |

> [!WARNING]
>
> The prices endpoint returns an **indicative grouped snapshot**. The data is periodically materialized and can lag behind the live marketplace. Use `GET /v1/listings` for the authoritative, real-time asking price of a specific item before placing an order.


## OpenAPI

````yaml GET /prices
openapi: 3.1.0
info:
  title: CSBoard API
  version: 1.0.0
  description: >-
    Market data over the CSBoard marketplace — live listings, floats, stickers,
    minAsk prices, FX rates — plus opt-in buying straight from your balance.
    Free to read, key-gated, built for automation.
  contact:
    name: CSBoard
    url: https://csboard.com/docs
servers:
  - url: https://csboard.com/v1
    description: Production
security:
  - bearerAuth: []
tags:
  - name: Status
    description: Liveness and freshness probes.
  - name: Market data
    description: Read the live catalog, prices, and FX rates.
  - name: Trading
    description: Buy listings from your CSBoard balance. Opt-in, key-gated.
  - name: Instant Sell
    description: >-
      Sell CS2, Dota 2 and Rust items from any Steam inventory to the CSBoard
      network and get paid to your balance. Invite-only.
  - name: P2P
    description: >-
      List your own CS2 skins on the CSBoard P2P market. Free — any valid key,
      no balance requirement.
  - name: Account
    description: Your balance, settled funds, and trading status.
  - name: Webhooks
    description: Register an endpoint and receive signed order updates instead of polling.
paths:
  /prices:
    get:
      tags:
        - Market data
      summary: minAsk price list
      description: >-
        The minAsk price list — one row per market hash name (+ wear + Doppler
        phase), with the cheapest current ask and how many are listed.
        Indicative grouped snapshot; can lag the live listing price. Pass
        `appId` to read Dota 2 (`570`) or Rust (`252490`) instead of CS2 — rows
        have the same keys, with the CS2-only fields `null` and `stickers`
        empty.
      operationId: listPrices
      parameters:
        - $ref: '#/components/parameters/AppId'
        - name: search
          in: query
          description: Full-text match on market hash name.
          schema:
            type: string
        - name: name
          in: query
          required: false
          description: >-
            Exact market_hash_name (case-insensitive) — the precise single-item
            lookup. Unlike fuzzy `search`, it isolates one item even when its
            name is a word-subset of a longer one (e.g. `Spectrum Case` vs
            `Spectrum 2 Case`). Takes precedence over `search`.
          schema:
            type: string
        - name: category
          in: query
          description: e.g. Rifle, Knife, Gloves.
          schema:
            type: string
        - name: wear
          in: query
          description: >-
            Item wear bucket. CS2 only — sent with another `appId` it answers
            `400 invalid_param`.
          schema:
            type: string
            enum:
              - Factory New
              - Minimal Wear
              - Field-Tested
              - Well-Worn
              - Battle-Scarred
        - name: rarity
          in: query
          description: e.g. Classified, Covert.
          schema:
            type: string
        - name: min_price
          in: query
          description: Minimum price in USD.
          schema:
            type: number
        - name: max_price
          in: query
          description: Maximum price in USD.
          schema:
            type: number
        - name: cursor
          in: query
          description: Keyset cursor from next_cursor.
          schema:
            type: string
        - name: limit
          in: query
          description: 1–500. Default 100.
          schema:
            type: integer
            minimum: 1
            maximum: 500
            default: 100
      responses:
        '200':
          description: A page of price rows.
          content:
            application/json:
              schema:
                type: object
                properties:
                  items:
                    type: array
                    items:
                      $ref: '#/components/schemas/PriceRow'
                  next_cursor:
                    type:
                      - string
                      - 'null'
                required:
                  - items
                  - next_cursor
              example:
                items:
                  - market_hash_name: AK-47 | Redline (Field-Tested)
                    wear: Field-Tested
                    doppler_phase: null
                    min_price_usd: 11.92
                    qty: 73
                next_cursor: null
        '400':
          description: >-
            A malformed or CS2-only parameter (`invalid_param`), or an `appId`
            this key may not use (`unsupported_game`).
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Error'
              examples:
                invalid_param:
                  summary: CS2-only filter sent with another game
                  value:
                    code: invalid_param
                    detail: >-
                      wear is CS2-only and is not supported for appId 252490
                      (Rust).
                unsupported_game:
                  summary: Game not available to this key
                  value:
                    code: unsupported_game
                    detail: >-
                      appId 440 is not available to this key. Supported: 730
                      (CS2), 570 (Dota 2), 252490 (Rust).
                    supported_app_ids:
                      - 730
                      - 570
                      - 252490
        '401':
          $ref: '#/components/responses/Unauthorized'
        '429':
          $ref: '#/components/responses/RateLimited'
components:
  parameters:
    AppId:
      name: appId
      in: query
      required: false
      description: >-
        Steam appId of the game. `730` = CS2 (the default), `570` = Dota 2,
        `252490` = Rust. Omit it and the endpoint answers for CS2 exactly as
        before. An appId this key may not use answers `400 unsupported_game`,
        whose `supported_app_ids` lists the ones it may — see `GET /games`.
      schema:
        type: integer
        enum:
          - 730
          - 570
          - 252490
        default: 730
  schemas:
    PriceRow:
      type: object
      properties:
        market_hash_name:
          type: string
        wear:
          type:
            - string
            - 'null'
        doppler_phase:
          type:
            - string
            - 'null'
        min_price_usd:
          type: number
          description: Cheapest current ask in USD.
        qty:
          type: integer
          description: How many are listed at or above this group.
      required:
        - market_hash_name
        - min_price_usd
        - qty
      description: >-
        One min-ask group. For Dota 2 and Rust (`appId` 570 / 252490) a group is
        one `market_hash_name`; `wear` and `doppler_phase` are `null`.
    Error:
      type: object
      description: >-
        All errors return { code, detail }. Some carry extra fields (e.g.
        price_moved adds current_total_usd, insufficient_balance adds
        required_usd/current_usd, item_unavailable adds unavailable_ids and, on
        CS2 buys, unknown_ids).
      properties:
        code:
          type: string
          description: >-
            Machine-readable error code, e.g. rate_limit_exceeded,
            trading_not_enabled, price_moved.
        detail:
          type: string
          description: Human-readable explanation.
      required:
        - code
    RateLimitError:
      type: object
      description: >-
        The `429` body of a per-key bucket. Endpoint-specific limits send only
        `code` and `detail`.
      properties:
        code:
          type: string
          description: >-
            `rate_limit_exceeded` for the key's buckets. Endpoint-specific
            limits use their own code (`snapshot_rate_limited`, `rate_limited`).
        detail:
          type: string
          description: Human-readable explanation.
        bucket:
          type: string
          enum:
            - read
            - trading
            - buy_orders
          description: Which bucket is spent.
        limit_per_min:
          type: integer
          description: That bucket's ceiling per minute.
        retry_after_sec:
          type: integer
          minimum: 1
          maximum: 60
          description: >-
            Seconds until the window restarts — the same number as
            `Retry-After`.
      required:
        - code
  responses:
    Unauthorized:
      description: Missing or invalid API key (`missing_api_key` or `invalid_api_key`).
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
          example:
            code: missing_api_key
            detail: >-
              Provide your API key via `Authorization: Bearer csb_pub_…`.
              Generate one at https://csboard.com/profile?tab=api
    RateLimited:
      description: >-
        A per-key limit is spent. The key's own buckets answer
        `rate_limit_exceeded` with `bucket` (`read`, `trading` or `buy_orders`),
        `limit_per_min` and `retry_after_sec`. `Retry-After` is the seconds left
        until the one-minute window restarts (1–60), not a flat 60.
        Endpoint-specific limits (`snapshot_rate_limited` on the price snapshot,
        `rate_limited` on Instant Sell) send only `code` and `detail`.
      headers:
        Retry-After:
          description: >-
            Seconds until the one-minute window restarts (1–60). Waiting that
            long is always enough.
          schema:
            type: integer
        X-RateLimit-Limit:
          $ref: '#/components/headers/X-RateLimit-Limit'
        X-RateLimit-Remaining:
          $ref: '#/components/headers/X-RateLimit-Remaining'
        X-RateLimit-Reset:
          $ref: '#/components/headers/X-RateLimit-Reset'
        X-RateLimit-Bucket:
          $ref: '#/components/headers/X-RateLimit-Bucket'
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/RateLimitError'
          example:
            code: rate_limit_exceeded
            detail: >-
              Read rate limit of 100 requests/min exceeded. The counter restarts
              in 23 s. For new listings use GET /v1/listings/stream instead of
              polling.
            bucket: read
            limit_per_min: 100
            retry_after_sec: 23
  headers:
    X-RateLimit-Limit:
      description: >-
        The ceiling per minute of the bucket this call spent (named in
        `X-RateLimit-Bucket`).
      schema:
        type: integer
      example: 3000
    X-RateLimit-Remaining:
      description: Calls left on that bucket in the current one-minute window.
      schema:
        type: integer
        minimum: 0
      example: 2987
    X-RateLimit-Reset:
      description: >-
        Seconds until the one-minute window restarts and the counter starts
        again.
      schema:
        type: integer
        minimum: 1
        maximum: 60
      example: 41
    X-RateLimit-Bucket:
      description: >-
        The bucket this call spent: `read` (reads and every other keyed call) or
        `trading` (buys, order reads, claims, cancels, balance). A `429` from
        the buy-order limit says `buy_orders`.
      schema:
        type: string
        enum:
          - read
          - trading
          - buy_orders
      example: trading
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer
      description: >-
        Send your key as a Bearer token on every request: `Authorization: Bearer
        csb_pub_...`. Generate keys in your CSBoard profile. Calls made with a
        key are metered only by that key's own limits — there is no per-IP limit
        on top — and every answer carries `X-RateLimit-Limit`,
        `X-RateLimit-Remaining`, `X-RateLimit-Reset` and `X-RateLimit-Bucket`
        for the bucket the call spent. See [Rate limits](/rate-limits).

````

This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.