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

# Depth

> Retrieve the order book depth for a given trading pair with aggregated price levels via the V4 API.

export const RelatedResources = ({children}) => {
  const ref = useRef(null);
  const [visible, setVisible] = useState(false);
  useEffect(() => {
    if (!ref.current) return;
    const el = ref.current;
    if (el.parentElement) {
      el.parentElement.appendChild(el);
    }
    setVisible(true);
  }, []);
  return <div ref={ref} className="related-resources" style={{
    marginTop: "2.5rem",
    paddingTop: "1.5rem",
    borderTop: "1px solid var(--border-color, #e5e7eb)",
    opacity: visible ? 1 : 0,
    transition: "opacity 0.15s ease-in"
  }}>
      <h2 style={{
    marginTop: 0
  }}>Related resources</h2>
      {children}
    </div>;
};

<Note>
  Public depth endpoints exclude Retail Price Improvement (RPI) orders. RPI orders appear only in private active orders (private API/WebSocket) and in the exchange UI order book (web and mobile).
</Note>

<RelatedResources>
  * [Orderbook](/api-reference/market-data/orderbook) — full order book with configurable depth and price-level aggregation.
  * [Recent trades](/api-reference/market-data/recent-trades) — latest executed trades for a market.
</RelatedResources>


## OpenAPI

````yaml /openapi/public/http-v4.yaml GET /api/v4/public/orderbook/depth/{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/depth/{market}:
    get:
      tags:
        - Public API V4
      summary: Depth
      description: >
        The endpoint retrieves depth price levels within ±2% of the market last
        price. Use when lightweight order book data is needed for a narrow price
        band around the current market price. The ±2% constraint limits the
        response to price levels near the last traded price, reducing payload
        size compared to the full order book.


        <Note>

        The API caches the response for 1 sec

        </Note>


        <Warning>

        Rate limit: 2000 requests/10 sec. See [Public API V4
        overview](/public/http-v4/index) for rate limit details.

        </Warning>
      parameters:
        - name: market
          in: path
          required: true
          description: Market pair name
          schema:
            type: string
            example: BTC_USDT
      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, not enabled for trading, or not enabled for the Coingecko
            feed that backs this endpoint.
          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.

````