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

# Available futures markets list

> Get a list of all available futures trading markets on WhiteBIT 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>;
};

<RelatedResources>
  * [Collateral markets list](/api-reference/market-data/collateral-markets-list) — markets available for collateral trading.
  * [Funding history](/api-reference/market-data/funding-history) — historical funding rate records for futures markets.
</RelatedResources>


## OpenAPI

````yaml /openapi/public/http-v4.yaml GET /api/v4/public/futures
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/futures:
    get:
      tags:
        - Public API V4
      summary: Available Futures Markets List
      description: >
        The endpoint returns detailed information for all available futures
        markets. Use the response to read current pricing, open interest,
        funding rates, and leverage bracket configuration. Each entry includes
        the predicted next funding rate, settlement timestamps, and maximum
        allowed position sizes per leverage level.


        <Note>

        The API caches the response for 1 second

        </Note>


        <Warning>

        Rate limit 2000 requests/10 sec.

        </Warning>
      parameters: []
      responses:
        '200':
          description: Successful response
          content:
            application/json:
              schema:
                type: object
                properties:
                  success:
                    type: boolean
                    example: true
                  message:
                    type: string
                    nullable: true
                    example: null
                  result:
                    type: array
                    items:
                      $ref: '#/components/schemas/FuturesMarket'
              example:
                success: true
                message: null
                result:
                  - ticker_id: BTC_PERP
                    stock_currency: BTC
                    money_currency: USDT
                    last_price: '24005.5'
                    stock_volume: '196965.591'
                    money_volume: '4737879075.7817'
                    bid: '24005.4'
                    ask: '24005.6'
                    high: '24295.1'
                    low: '23765.3'
                    product_type: Perpetual
                    open_interest: '6000'
                    index_price: '24019.25'
                    index_name: Bitcoin
                    index_currency: BTC
                    funding_rate: '0.000044889033693137'
                    next_funding_rate_timestamp: '1660665600000'
                    brackets:
                      '1': 0
                      '2': 0
                      '3': 0
                      '5': 0
                      '10': 0
                      '20': 0
                      '50': 20
                      '100': 50
                    max_leverage: 100
                    funding_interval_minutes: 300
components:
  schemas:
    FuturesMarket:
      type: object
      properties:
        ticker_id:
          type: string
          description: Identifier of a ticker with delimiter to separate base/target
          example: BTC_PERP
        stock_currency:
          type: string
          description: Symbol/currency code of base pair
          example: BTC
        money_currency:
          type: string
          description: Symbol/currency code of target pair
          example: USDT
        last_price:
          type: string
          description: >-
            Last transacted price of base currency based on given target
            currency
          example: '24005.5'
        stock_volume:
          type: string
          description: 24 hour trading volume in base pair volume
          example: '196965.591'
        money_volume:
          type: string
          description: 24 hour trading volume in target pair volume
          example: '4737879075.7817'
        bid:
          type: string
          description: Current highest bid price
          example: '24005.4'
        ask:
          type: string
          description: Current lowest ask price
          example: '24005.6'
        high:
          type: string
          description: Rolling 24-hours highest transaction price
          example: '24295.1'
        low:
          type: string
          description: Rolling 24-hours lowest transaction price
          example: '23765.3'
        product_type:
          type: string
          description: Derivative product type for the market.
          enum:
            - Perpetual
            - Futures
            - Options
          example: Perpetual
        open_interest:
          type: string
          description: >-
            Current open interest in contracts (point-in-time snapshot, not a
            24-hour delta or volume).
          example: '6000'
        index_price:
          type: string
          description: Underlying index price
          example: '24019.25'
        index_name:
          type: string
          description: Name of the underlying index if any
          example: Bitcoin
        index_currency:
          type: string
          description: Underlying currency for index
          example: BTC
        funding_rate:
          type: string
          description: >-
            Predicted funding rate for the next settlement interval. Fluctuates
            in real time until settlement occurs. See GET
            /api/v4/public/funding-history/{market} for historical funding rate
            records.
          example: '0.000044889033693137'
        next_funding_rate_timestamp:
          type: string
          description: >-
            Unix timestamp in milliseconds of the next funding settlement.
            13-digit value (millisecond precision).
          example: '1660665600000'
        brackets:
          type: object
          description: >-
            Leverage brackets defining position size limits. Object keys are
            leverage multipliers (e.g., "1", "2", "5", "10", "20", "50", "100").
            Values are the maximum allowed open position size in USDT equivalent
            at the corresponding leverage level.
          additionalProperties:
            type: integer
          example:
            '1': 0
            '2': 0
            '3': 0
            '5': 0
            '10': 0
            '20': 0
            '50': 20
            '100': 50
        max_leverage:
          type: integer
          description: Maximum leverage multiplier allowed for the market.
          example: 100
        funding_interval_minutes:
          type: integer
          description: Funding interval in minutes
          example: 300

````