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

# Orderbook

> Retrieve the full order book for a trading pair with individual price levels via the V4 API.

<Note>
  Public order book responses exclude Retail Price Improvement (RPI) orders. Private active order endpoints and private WebSocket streams return RPI orders. The exchange UI order book (web and mobile) displays RPI orders.
</Note>

* [Depth](/api-reference/market-data/depth) — lightweight order book within ±2% of the last price.
* [Recent trades](/api-reference/market-data/recent-trades) — latest executed trades for a market.


## OpenAPI

````yaml /openapi/public/http-v4.yaml GET /api/v4/public/orderbook/{market}
openapi: 3.0.3
info:
  title: Public HTTP API V4
  description: >
    WhiteBIT Public HTTP API V4 for market data and trading information.

    Base URL: https://whitebit.com

    All endpoints return time in Unix-time format.

    All endpoints return either a JSON object or array.

    Use HTTP method GET for API calls.

    Send parameters as query string when an endpoint requires them.


    <Warning>

    Rate limit: 2000 requests/10 sec for most endpoints (specific limits noted
    per endpoint).

    </Warning>


    ## Caching and data freshness


    Most public endpoints serve cached data. The cache is **shared across all
    callers** — values are keyed by the resource (market, currency), never by
    account — and invalidates on a **time basis only**: an upstream change
    becomes visible after the next refresh, not immediately.


    Two refresh tiers apply:


    - **Reference data** (`markets`, `assets`, `fee`, `collateral/markets`,
    `futures`) refreshes from the database on a fixed interval, ranging from
    about 10 seconds to about 1 minute depending on the endpoint.

    - **Market data** (`trades`, `orderbook`, `orderbook/depth`, `ticker`) uses
    a short-lived cache, about 1 second by default.


    `time` and `ping` are computed per request and are not cached. Each endpoint
    states its own refresh interval. Polling faster than that interval returns
    identical data and consumes rate-limit budget without producing fresher
    results.


    ## Error responses


    Public V4 endpoints do not share a single error schema. Depending on the
    endpoint, an error arrives in one of three shapes (there is no `params`
    field on any public error):


    - **Flat validation bag (HTTP 422)** — `{ "<field>": ["<message>"] }`. No
    envelope. Used by the market endpoints (`orderbook`, `orderbook/depth`,
    `trades`). Example: `{ "market": ["Market is not available."] }`. On
    `funding-history` the values are single strings rather than arrays.

    - **Wrapped, HTTP 200 even on validation errors** — `{ "success": false,
    "message": { "<field>": ["<message>"] }, "result": null }`. Used by the V4
    `kline` endpoint (not part of this portal — the documented Kline endpoint is
    V1).

    - **Wrapped string message (HTTP 4xx)** — `{ "success": false, "message":
    "<string>", "errors": [] }`. Used by the margin/futures collateral subset of
    endpoints. Parameterless endpoints (`markets`, `ticker`, `assets`, `fee`)
    take no input and so produce no validation errors — they fail only at the
    infrastructure level below.


    Common failures are produced at the infrastructure layer, not by the
    application, and do not follow these shapes:


    - **Maintenance** — every endpoint returns **HTTP 503** with a non-JSON body
    served by the gateway.

    - **Rate limit exceeded** — **HTTP 429** with a non-JSON body served by the
    gateway/CDN.

    - **Internal server error** — **HTTP 500** with a flat body `{ "error":
    ["Internal server error."] }`.

    - **Unknown route** — **HTTP 404** with an empty body.
  version: 4.0.0
servers:
  - url: https://whitebit.com
    description: WhiteBIT Global Server
  - url: https://whitebit.eu
    description: WhiteBIT EU Server
security: []
tags:
  - name: Public API V4
    description: Public endpoints for market data, trading information, and platform status
paths:
  /api/v4/public/orderbook/{market}:
    get:
      tags:
        - Public API V4
      summary: Orderbook
      description: >
        The endpoint retrieves the current [order book](/glossary#order-book) as
        two arrays ([bids](/glossary#bid) / [asks](/glossary#ask)) with
        additional parameters.


        <Note>

        The API caches the response for 100 ms

        </Note>


        <Warning>

        Rate limit 600 requests/10 sec.

        </Warning>
      parameters:
        - name: market
          in: path
          required: true
          description: Market pair name
          schema:
            type: string
            example: BTC_USDT
        - name: limit
          in: query
          required: false
          description: >-
            Orders depth quantity: 0 - 100. Not defined or 0 will return 100
            entries.
          schema:
            type: integer
            minimum: 0
            maximum: 100
            default: 100
            example: 100
        - name: level
          in: query
          required: false
          description: >-
            Aggregation level for price grouping. Level 0 applies no
            aggregation. Levels 1–5 provide increasing aggregation of the order
            book.
          schema:
            type: integer
            minimum: 0
            maximum: 5
            default: 0
            example: 2
      responses:
        '200':
          description: Successful response
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/OrderbookResponse'
        '422':
          description: >-
            Validation error. Returned when the `market` path parameter is
            unknown or not enabled for trading.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PublicValidationError'
              example:
                market:
                  - Market is not available.
components:
  schemas:
    OrderbookResponse:
      type: object
      properties:
        ticker_id:
          type: string
          description: Market Name
          example: BTC_PERP
        timestamp:
          type: integer
          description: Current timestamp
          example: 1594391413
        asks:
          type: array
          description: Array of ask orders
          items:
            type: array
            items:
              type: string
            minItems: 2
            maxItems: 2
            example:
              - '9184.41'
              - '0.773162'
            description: >-
              [price, quantity] — price in quote currency, quantity in base
              currency
        bids:
          type: array
          description: Array of bid orders
          items:
            type: array
            items:
              type: string
            minItems: 2
            maxItems: 2
            example:
              - '9181.19'
              - '0.010873'
            description: >-
              [price, quantity] — price in quote currency, quantity in base
              currency
    PublicValidationError:
      type: object
      description: >-
        Flat field-keyed validation error (HTTP 422) returned by the market-data
        endpoints. Each key is the offending request field and the value is an
        array of human-readable messages. There is no success/message envelope
        and no `params` field.
      additionalProperties:
        type: array
        items:
          type: string
      example:
        market:
          - Market is not available.

````