WhiteBIT API Platform

https://docs.whitebit.com
Admin
WhiteBIT API Platform provides comprehensive trading APIs for accessing global cryptocurrency...
Tokens:399,949
Snippets:2,879
Trust Score:9.8
Update:5 months ago
Show doc for...
Tokens:
Raw
### Install Go SDK

Source: https://docs.whitebit.com/sdks

Use `go get` to install the official WhiteBIT SDK for Go.

```bash
go get github.com/whitebit-exchange/go-sdk
```

--------------------------------

### Make an Authenticated API Call (Python with Helper)

Source: https://docs.whitebit.com/api-reference/overview

This Python example utilizes the WhiteBIT API Quick Start Helper to authenticate and retrieve the main account balance. Ensure you have the helper library installed and replace placeholders with your API key and secret.

```python
# Use the API Quick Start Helper: https://github.com/whitebit-exchange/api-quickstart
from whitebit import Whitebit

wb = Whitebit(api_key="YOUR_API_KEY", api_secret="YOUR_API_SECRET")
balance = wb.main_account_balance()
print(balance)
```

--------------------------------

### Quick Start CLI Commands

Source: https://docs.whitebit.com/guides/cli

Set up API credentials using environment variables and execute basic commands to verify setup, check balances, and place an order.

```bash
# 1. Set credentials (required for account and trading commands)
export WHITEBIT_API_KEY="YOUR_API_KEY"
export WHITEBIT_API_SECRET="YOUR_SECRET"

# 2. Verify setup — no authentication required
whitebit market list

# 3. Check the trading balance
whitebit balance trade

# 4. Place a limit order
whitebit trade spot limit-order BTC_USDT buy 0.001 50000
```

--------------------------------

### Go Quick Start Example

Source: https://docs.whitebit.com/sdks

Initialize the WhiteBIT client with API credentials from environment variables and fetch the trade balance. Ensure your API key and secret are set as WB_API_KEY and WB_API_SECRET.

```go
// TODO: verify SDK method names against github.com/whitebit-exchange/go-sdk
package main

import (
	"fmt"
	whitebit "github.com/whitebit-exchange/go-sdk"
	"os"
)

func main() {
	client := whitebit.NewClient(os.Getenv("WB_API_KEY"), os.Getenv("WB_API_SECRET"))
	balance, err := client.GetTradeBalance()
	if err != nil {
		panic(err)
	}
	fmt.Println(balance)
}
```

--------------------------------

### PHP Quick Start Example

Source: https://docs.whitebit.com/sdks

Initialize the WhiteBIT client with API credentials from environment variables and fetch the trade balance. Ensure your API key and secret are set as WB_API_KEY and WB_API_SECRET.

```php
<?php
// TODO: verify SDK method names against github.com/whitebit-exchange/php-sdk
require 'vendor/autoload.php';

$client = new 
WhiteBIT
Client(
    apiKey: getenv('WB_API_KEY'),
    apiSecret: getenv('WB_API_SECRET')
);
$balance = $client->getTradeBalance();
print_r($balance);

```

--------------------------------

### Provide API credentials for session start

Source: https://docs.whitebit.com/guides/mcp-server

Example of how to provide API key and secret for authenticated access to WhiteBIT API tools. Credentials are passed as parameters at the start of a session.

```text
API key is YOUR_API_KEY and secret is YOUR_SECRET. Show the spot balance.
```

--------------------------------

### Python Quick Start Example

Source: https://docs.whitebit.com/sdks

Initialize the WhiteBIT client with API credentials from environment variables and fetch the trade balance. Ensure your API key and secret are set as WB_API_KEY and WB_API_SECRET.

```python
# TODO: verify SDK method names against github.com/whitebit-exchange/python-sdk
import os
from whitebit import Client

client = Client(
	api_key=os.environ["WB_API_KEY"],
	api_secret=os.environ["WB_API_SECRET"]
)
balance = client.get_trade_balance()
print(balance)
```

--------------------------------

### Get Fixed Plans Request Example

Source: https://docs.whitebit.com/api-reference/account-wallet/get-plans

This example demonstrates the structure of a request to the getFixedPlans endpoint. Ensure 'request' and 'nonce' are properly generated for authentication. This endpoint is only available for B2B partners.

```json
{
  "ticker": "USDT",
  "request": "{{request}}",
  "nonce": "{{nonce}}"
}
```

--------------------------------

### Collateral Account Balance Request Example

Source: https://docs.whitebit.com/api-reference/collateral-trading/collateral-account-balance

This example shows how to structure a request to get the collateral balance for a specific asset, BTC. Ensure you include your authentication credentials.

```json
{
  "ticker": "BTC",
  "request": "{{request}}",
  "nonce": "{{nonce}}"
}
```

--------------------------------

### Create and Apply WhiteBIT Code

Source: https://docs.whitebit.com/platform/whitebit-codes

This section provides a step-by-step guide with cURL examples on how to create a WhiteBIT code for a specified amount and currency, and then how to apply that code on another account. It also shows the expected JSON responses for each step.

```APIDOC
## Create a WhiteBIT code

### Description
Creates a unique code for a specified amount and currency, which can then be used to transfer funds.

### Method
POST

### Endpoint
/api/v4/main-account/codes

### Request Body
- **ticker** (string) - Required - The currency ticker (e.g., ETH).
- **amount** (string) - Required - The amount to be transferred.
- **passphrase** (string) - Required - A secret passphrase for the code.
- **request** (string) - Required - The API endpoint path.
- **nonce** (integer) - Required - A unique number for the request.

### Request Example
```json
{
  "ticker": "ETH",
  "amount": "0.002",
  "passphrase": "mySecretPass1",
  "request": "/api/v4/main-account/codes",
  "nonce": 1
}
```

### Response
#### Success Response (200)
- **code** (string) - The generated WhiteBIT code.
- **message** (string) - Confirmation message.
- **external_id** (string) - An external identifier for the transaction.

#### Response Example
```json
{
  "code": "WBe11f4fce-2a53-4edc-b195-66b693bd77e3ETH",
  "message": "Code was successfully created",
  "external_id": "be08a482-5faf-11ed-9b6a-0242ac120002"
}
```

## Apply the code on the recipient's account

### Description
Applies a previously created WhiteBIT code to transfer funds to the recipient's account.

### Method
POST

### Endpoint
/api/v4/main-account/codes/apply

### Request Body
- **code** (string) - Required - The WhiteBIT code to apply.
- **passphrase** (string) - Required - The passphrase used when creating the code.
- **request** (string) - Required - The API endpoint path.
- **nonce** (integer) - Required - A unique number for the request.

### Request Example
```json
{
  "code": "WBe11f4fce-2a53-4edc-b195-66b693bd77e3ETH",
  "passphrase": "mySecretPass1",
  "request": "/api/v4/main-account/codes/apply",
  "nonce": 2
}
```

### Response
#### Success Response (200)
- **message** (string) - Confirmation message.
- **ticker** (string) - The currency ticker of the applied code.
- **amount** (string) - The amount transferred.
- **external_id** (string) - An external identifier for the transaction.

#### Response Example
```json
{
  "message": "Code was successfully applied",
  "ticker": "ETH",
  "amount": "0.002",
  "external_id": "be08a482-5faf-11ed-9b6a-0242ac120002"
}
```
```

--------------------------------

### Install PHP SDK

Source: https://docs.whitebit.com/sdks

Use `composer` to install the official WhiteBIT SDK for PHP.

```bash
composer require whitebit/api-sdk
```

--------------------------------

### Start WhiteBIT MCP Server

Source: https://docs.whitebit.com/guides/mcp-server

Starts the WhiteBIT MCP server using the `uvx` command. This command is registered in the AI client configurations and runs automatically when the client starts.

```bash
uvx whitebit-mcp
```

--------------------------------

### Install Python SDK

Source: https://docs.whitebit.com/sdks

Use `pip` to install the official WhiteBIT SDK for Python.

```bash
pip install whitebit
```

--------------------------------

### Subscription Example

Source: https://docs.whitebit.com/websocket/overview

An example illustrating how to subscribe to a data stream, such as candle data, and the expected success response.

```APIDOC
## Example: Subscription

### Request
```json
{
  "id": 0,
  "method": "candles_subscribe",
  "params": []
}
```

### Response
```json
{
  "id": 0,
  "result": {
    "status": "success"
  },
  "error": null
}
```
```

--------------------------------

### Install uv Package Manager (Windows)

Source: https://docs.whitebit.com/guides/mcp-server

Installs the `uv` package manager on Windows using PowerShell. This command bypasses the execution policy to download and run the installation script.

```powershell
powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"
```

--------------------------------

### Ping/Pong Example

Source: https://docs.whitebit.com/websocket/overview

An example demonstrating a simple `ping` request and its corresponding `pong` response, used to check the WebSocket connection's liveness.

```APIDOC
## Example: Ping/Pong

### Request
```json
{
  "id": 0,
  "method": "ping",
  "params": []
}
```

### Response
```json
{
  "id": 0,
  "result": "pong",
  "error": null
}
```
```

--------------------------------

### Run WhiteBIT MCP Setup Command

Source: https://docs.whitebit.com/guides/mcp-server

Executes the `uvx whitebit-mcp-setup` command to configure the MCP server for supported AI clients. Replace YOUR_API_KEY and YOUR_SECRET_KEY with your actual credentials.

```bash
uvx whitebit-mcp-setup --public=YOUR_API_KEY --secret=YOUR_SECRET_KEY
```

--------------------------------

### Get Kline Data

Source: https://docs.whitebit.com/api-reference/market-data/kline

Fetches historical kline data for a specified market. You can filter by interval, limit, start, and end times.

```APIDOC
## GET /api/v1/public/kline

### Description
Retrieves historical kline (candlestick) data for a specified market. This endpoint is useful for technical analysis and backtesting trading strategies.

### Method
GET

### Endpoint
`https://whitebit.com/api/v1/public/kline` or `https://whitebit.eu/api/v1/public/kline`

### Parameters
#### Query Parameters
- **market** (string) - Required - Available market. Example: `"BTC_USDT"`
- **start** (integer) - Optional - Start time in seconds, default value is one week earlier from the current time. Cannot be greater than end parameter. Example: `1596848400`
- **end** (integer) - Optional - End time in seconds, default value is current time. Cannot be less than start parameter. Example: `1596927600`
- **interval** (enum<string>) - Optional - Possible values - `1m`, `3m`, `5m`, `15m`, `30m`, `1h`, `2h`, `4h`, `6h`, `8h`, `12h`, `1d`, `3d`, `1w`, `1M`. Default value is `1h`.
- **limit** (integer) - Optional - Possible values from 1 to 1440. Default value is `1440`.

### Response
#### Success Response (200)
- **success** (boolean) - Indicates if the request was successful.
- **message** (string | null) - Contains an error message if the request failed, otherwise null.
- **result** (array of arrays) - An array where each inner array represents a kline and contains: [Time in seconds, Open, Close, High, Low, Volume stock, Volume money].

#### Response Example
```json
{
  "success": true,
  "message": null,
  "result": [
    [
      1631440800,
      "45865.62",
      "45958.14",
      "45981.3",
      "45750.23",
      "15.327634",
      "703140.24230131"
    ]
  ]
}
```
```

--------------------------------

### Get Flex Payment History Request Example

Source: https://docs.whitebit.com/api-reference/account-wallet/get-flex-payment-history

This example demonstrates the structure of a request to retrieve Flex payment history. It includes optional filters for pagination, plan, investment, transaction, and date range. Ensure 'request' and 'nonce' are properly generated.

```json
{
  "limit": 50,
  "offset": 0,
  "plan": "8f2e9d3c-1a4b-4c2d-9e5f-6a7b8c9d0e1f",
  "investment": "inv_123",
  "transaction": "tx_456",
  "dateFrom": 1640995200,
  "dateTo": 1641081600,
  "request": "{{request}}",
  "nonce": "{{nonce}}"
}
```

--------------------------------

### API Response: Successful Transfer

Source: https://docs.whitebit.com/api-reference/account-wallet/transfer-between-balances

This example indicates a successful API request where all validations passed and the transaction process has started. An empty array signifies success.

```json
[]
```

--------------------------------

### Get Existing Deposit Address

Source: https://docs.whitebit.com/guides/payment-integration

Retrieves the existing deposit address for a given ticker and network. This is suitable for single-wallet setups or treasury management where a consistent address is preferred.

```APIDOC
## POST /api/v4/main-account/address

### Description
Returns the existing deposit address for the specified ticker and network.

### Method
POST

### Endpoint
/api/v4/main-account/address

### Parameters
#### Request Body
- **ticker** (string) - Required - The cryptocurrency ticker (e.g., BTC).
- **network** (string) - Optional - The network to use for the address (e.g., ERC20, TRC20).

### Request Example
```json
{
  "ticker": "BTC"
}
```

### Response
#### Success Response (200)
- **account** (object) - Contains account details.
  - **address** (string) - The existing deposit address.

#### Response Example
```json
{
  "account": {
    "address": "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa"
  }
}
```
```

--------------------------------

### Install MCP and WhiteBIT SDK (Without Docker)

Source: https://docs.whitebit.com/guides/mcp-server

Installs the necessary Python packages (`mcp` and `whitebit-python-sdk`) and runs the MCP server using `mcp run server.py`. The server will listen on `http://0.0.0.0:8000`.

```bash
pip install mcp whitebit-python-sdk
mcp run server.py
```

--------------------------------

### Get Flex Investment History Request Example

Source: https://docs.whitebit.com/api-reference/account-wallet/get-flex-investment-history

This example demonstrates how to structure a request to retrieve flex investment history. It includes common filtering parameters such as limit, offset, plan, investment, transaction, date range, and action types. Ensure to replace placeholders like '{{request}}' and '{{nonce}}' with actual values.

```json
{
  "limit": 50,
  "offset": 0,
  "plan": "8f2e9d3c-1a4b-4c2d-9e5f-6a7b8c9d0e1f",
  "investment": "inv_123",
  "transaction": "tx_456",
  "dateFrom": 1640995200,
  "dateTo": 1641081600,
  "actionTypes": [
    1,
    2,
    4
  ],
  "request": "{{request}}",
  "nonce": "{{nonce}}"
}
```

--------------------------------

### Python Market Making Setup

Source: https://docs.whitebit.com/guides/market-maker-guide

Initializes necessary libraries and constants for interacting with the WhiteBIT API using Python. This includes API credentials, base URL, and modules for cryptographic operations and HTTP requests.

```python
import hashlib
import hmac
import json
import time
import base64
import requests

API_KEY = "YOUR_API_KEY"
API_SECRET = "YOUR_SECRET"
BASE_URL = "https://whitebit.com"

```

--------------------------------

### Python SDK Example

Source: https://docs.whitebit.com/platform/whitebit-codes

This Python code demonstrates how to interact with the WhiteBIT API to create a code and then apply it. It includes functions for sending authenticated requests and handling responses.

```APIDOC
```python
import time
import json
import hmac
import hashlib
import base64
import requests

API_KEY = "YOUR_API_KEY"
SECRET = "YOUR_SECRET"
BASE_URL = "https://whitebit.com"

def send_request(path, data):
    data["request"] = path
    data["nonce"] = int(time.time() * 1000)
    payload = base64.b64encode(json.dumps(data).encode())
    signature = hmac.new(
        SECRET.encode(), payload, hashlib.sha512
    ).hexdigest()
    headers = {
        "X-TXC-APIKEY": API_KEY,
        "X-TXC-PAYLOAD": payload.decode(),
        "X-TXC-SIGNATURE": signature,
        "Content-Type": "application/json",
    }
    return requests.post(BASE_URL + path, headers=headers, json=data)

# Step 1: Create a WhiteBIT code
create = send_request("/api/v4/main-account/codes", {
    "ticker": "ETH",
    "amount": "0.002",
    "passphrase": "mySecretPass1",
})
create_data = create.json()
print("Code:", create_data["code"])
print("External ID:", create_data["external_id"])

# Step 2: Apply the code on the recipient's account
apply = send_request("/api/v4/main-account/codes/apply", {
    "code": create_data["code"],
    "passphrase": "mySecretPass1",
})
apply_data = apply.json()
print("Applied:", apply_data["amount"], apply_data["ticker"])
```
```

--------------------------------

### cURL: Get Trade Account Balance

Source: https://docs.whitebit.com/guides/first-api-call

This cURL command demonstrates how to make a POST request to the trade account balance endpoint. The payload and signature must be pre-computed using a separate implementation, such as the provided Python example.

```bash
# The payload and signature must be computed before calling curl.
# Use the Python example for a complete signing implementation.
# Replace BASE64_PAYLOAD and HMAC_SIGNATURE with computed values.

curl -X POST https://whitebit.com/api/v4/trade-account/balance \
  -H "Content-Type: application/json" \
  -H "X-TXC-APIKEY: YOUR_API_KEY" \
  -H "X-TXC-PAYLOAD: BASE64_PAYLOAD" \
  -H "X-TXC-SIGNATURE: HMAC_SIGNATURE" \
  -d '{"request":"/api/v4/trade-account/balance","nonce":"1700000000000"}'
```

--------------------------------

### Get Mining Payout Destination OpenAPI Spec

Source: https://docs.whitebit.com/api-reference/mining-pool/get-payout-destination

This OpenAPI specification defines the endpoint for retrieving the mining payout destination. It includes request parameters, response schemas, and example responses for both successful and error cases. Rate limit is 1000 requests/10 sec.

```yaml
openapi: 3.0.3
info:
  title: WhiteBIT Private HTTP API V4
  description: |
    WhiteBIT Private HTTP API V4 for Main balance changes.

    Base URL: https://whitebit.com

    All endpoints return time in Unix-time format.
    All endpoints return either a JSON object or array.
    For receiving responses from API calls please use http method POST.
  version: 4.0.0
  contact:
    name: WhiteBIT Support
    email: support@whitebit.com
    url: https://whitebit.com
servers:
  - url: https://whitebit.com
    description: WhiteBIT Global Server
  - url: https://whitebit.eu
    description: WhiteBIT EU Server
security:
  - ApiKeyAuth: []
    PayloadAuth: []
    SignatureAuth: []
tags:
  - name: Main Account
    description: Main account balance and operations
  - name: Deposit
    description: Cryptocurrency and fiat deposit operations
  - name: Withdraw
    description: Cryptocurrency and fiat withdrawal operations
  - name: Transfer
    description: Balance transfer operations
  - name: Codes
    description: WhiteBIT codes operations
  - name: Crypto Lending - Fixed
    description: Fixed crypto lending plans
  - name: Crypto Lending - Flex
    description: Flexible crypto lending plans
  - name: Fees
    description: Fee information
  - name: Sub-Account
    description: Sub-account management
  - name: Sub-Account API Keys
    description: Sub-account API key management
  - name: Mining Pool
    description: Mining pool operations
  - name: Credit Line
    description: Credit line information
  - name: JWT
    description: JWT token management
paths:
  /api/v4/mining/payout-destination:
    post:
      tags:
        - Mining Pool
      summary: Get Payout Destination
      description: >
        Returns the current payout destination setting for a specific mining
        account belonging to the authenticated user.


        <Warning>

        Rate limit: 1000 requests/10 sec.

        </Warning>
      operationId: getMiningPayoutDestination
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              required:
                - accountName
              properties:
                accountName:
                  type: string
                  description: Mining pool account name
                  example: my_miner_01
      responses:
        '200':
          description: Successful response
          content:
            application/json:
              schema:
                type: object
                properties:
                  payoutDestination:
                    type: string
                    enum:
                      - main_balance
                      - external_address
                    description: Payout destination type
                  externalAddress:
                    type: string
                    nullable: true
                    description: External BTC address (null if destination is main_balance)
              example:
                payoutDestination: main_balance
                externalAddress: null
        '400':
          description: Validation failed
          content:
            application/json:
              schema:
                type: object
                properties:
                  code:
                    type: integer
                  message:
                    type: string
                  errors:
                    type: object
              example:
                code: 0
                message: Validation failed
                errors:
                  user:
                    - Mining account not found.
components:
  securitySchemes:
    ApiKeyAuth:
      type: apiKey
      in: header
      name: X-TXC-APIKEY
      description: The public WhiteBIT API key.
    PayloadAuth:
      type: apiKey
      in: header
      name: X-TXC-PAYLOAD
      description: Base64-encoded JSON request body.
    SignatureAuth:
      type: apiKey
      in: header
      name: X-TXC-SIGNATURE
      description: >-
        HMAC-SHA512 signature of the payload, hex-encoded. Computed as
        hex(HMAC-SHA512(payload, api_secret)).

```

--------------------------------

### Initiate and Handle WhiteBIT OAuth 2.0 Flow in Go

Source: https://docs.whitebit.com/platform/oauth/usage/overview

This Go code demonstrates how to initiate the OAuth 2.0 flow by redirecting the user to the WhiteBIT login page and how to handle the callback to exchange the authorization code for an access token. Ensure to replace placeholder values for CLIENT_ID and CLIENT_SECRET. In production, the 'state' parameter should be securely managed, typically within user sessions.

```Go
package main

import (
	"bytes"
	"context"
	"crypto/rand"
	"encoding/base64"
	"encoding/json"
	"fmt"
	"io"
	"log"
	"net/http"
	"net/url"
	"time"
)

// TokenResponse represents the OAuth token response
type TokenResponse struct {
	Data struct {
		AccessToken  string `json:"access_token"`
		ExpiresIn    int    `json:"expires_in"`
		RefreshToken string `json:"refresh_token"`
		Scope        string `json:"scope"`
		TokenType    string `json:"token_type"`
	} `json:"data"`
}

const BASE_URL = "https://whitebit.com"
const CLIENT_ID = "YOUR_CLIENT_ID"
const CLIENT_SECRET = "YOUR_CLIENT_SECRET"

// Initiate OAuth flow
func initiateOAuthFlowHandler(w http.ResponseWriter, r *http.Request) {
	b := make([]byte, 32)
	rand.Read(b)
	state := base64.RawURLEncoding.EncodeToString(b)

	// In production, store state in session

	authURL, _ := url.Parse(BASE_URL + "/auth/login")
	q := authURL.Query()
	q.Set("clientId", CLIENT_ID)
	q.Set("state", state)
	authURL.RawQuery = q.Encode()

	http.Redirect(w, r, authURL.String(), http.StatusFound)
}

// Handle OAuth callback
func oauthCallbackHandler(w http.ResponseWriter, r *http.Request) {
	code := r.URL.Query().Get("code")
	state := r.URL.Query().Get("state")

	// Verify state here...

	token, err := exchangeCodeForToken(r.Context(), code)
	if err != nil {
		http.Error(w, "Authentication failed", http.StatusInternalServerError)
		return
	}

	fmt.Fprintf(w, "Token received: %s", token.Data.AccessToken)
}

func exchangeCodeForToken(ctx context.Context, code string) (*TokenResponse, error) {
	data := url.Values{}
	data.Set("client_id", CLIENT_ID)
	data.Set("client_secret", CLIENT_SECRET)
	data.Set("code", code)

	resp, err := http.PostForm(BASE_URL+"/oauth2/token", data)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()

	var tokenResponse TokenResponse
	json.NewDecoder(resp.Body).Decode(&tokenResponse)
	return &tokenResponse, nil
}

```

--------------------------------

### Get My Codes

Source: https://docs.whitebit.com/api-reference/account-wallet/overview

Get created codes

```APIDOC
## Get My Codes

### Description
Get created codes.

### Method
GET

### Endpoint
/api-reference/account-wallet/get-my-codes
```

--------------------------------

### Get Codes History

Source: https://docs.whitebit.com/api-reference/account-wallet/overview

Get codes history

```APIDOC
## Get Codes History

### Description
Get codes history.

### Method
GET

### Endpoint
/api-reference/account-wallet/get-codes-history
```

--------------------------------

### Place Collateral Limit Order (Python)

Source: https://docs.whitebit.com/products/margin-futures/quickstart

Place a limit order using Python. This example demonstrates creating a buy order for BTC_USDT with a price set far below the market to keep it open.

```python
order = send_request("/api/v4/order/collateral/limit", {
    "market": "BTC_USDT",
    "side": "buy",
    "amount": "0.001",
    "price": "30000"  # Price far below market — order will not fill
})
print(order)
orderId = order.get("orderId")
print(f"Order ID: {orderId}")
```

--------------------------------

### API Usage Examples for Client Orders

Source: https://docs.whitebit.com/guides/client-order-id

Demonstrates how to construct requests for creating, querying, canceling, and retrieving historical client orders using a structured clientOrderId.

```javascript
const createClientOrder = {
    market: "BTC_USDT",
    side: "buy",
    amount: "0.01",
    price: "40000",
    clientOrderId: "brk-ind123-limit-spot-1678234567"
  };

  // Query client's active orders
  const queryClientOrders = {
    market: "BTC_USDT",
    clientOrderId: "brk-ind123-limit-spot-1678234567"
  };

  // Cancel client's order using clientOrderId
  const cancelClientOrder = {
    market: "BTC_USDT",
    clientOrderId: "brk-ind123-limit-spot-1678234567"
  };

  // Get historical data for client orders
  const getClientOrderHistory = {
    market: "BTC_USDT",
    clientOrderId: "brk-ind123-limit-spot-1678234567",
    limit: 50,
    offset: 0
  };
```

--------------------------------

### Get Investments History

Source: https://docs.whitebit.com/api-reference/account-wallet/overview

Get fixed investments history

```APIDOC
## Get Investments History

### Description
Get fixed investments history.

### Method
GET

### Endpoint
/api-reference/account-wallet/get-investments-history
```

--------------------------------

### Get Plans

Source: https://docs.whitebit.com/api-reference/account-wallet/overview

Get available fixed lending plans

```APIDOC
## Get Plans

### Description
Get available fixed lending plans.

### Method
GET

### Endpoint
/api-reference/account-wallet/get-plans
```

--------------------------------

### Place a Limit Order with Python

Source: https://docs.whitebit.com/products/spot/quickstart

This Python snippet shows how to place a limit order using the `send_request` function. It demonstrates creating a buy order for BTC_USDT with a specified amount and price.

```python
order = send_request("/api/v4/order/new", {
    "market": "BTC_USDT",
    "side": "buy",
    "amount": "0.0001",
    "price": "30000"       # Well below market — adjust if needed
})
print(order)
orderId = order.get("orderId")
print(f"Order ID: {orderId}")
```

--------------------------------

### Get Interest Payments History

Source: https://docs.whitebit.com/api-reference/account-wallet/overview

Get interest payments history

```APIDOC
## Get Interest Payments History

### Description
Get interest payments history.

### Method
GET

### Endpoint
/api-reference/account-wallet/get-interest-payments-history
```

--------------------------------

### Create Flex Investment Request Example

Source: https://docs.whitebit.com/api-reference/account-wallet/create-flex-investment

This example demonstrates the structure of a request to create a new investment in a Flex plan. Ensure all required fields, including plan ID, amount, request signature, and nonce, are correctly provided.

```json
{
  "plan": "8f2e9d3c-1a4b-4c2d-9e5f-6a7b8c9d0e1f",
  "amount": "1000.500000",
  "withReinvest": true,
  "request": "{{request}}",
  "nonce": "{{nonce}}"
}
```

--------------------------------

### Get Cryptocurrency Deposit Address

Source: https://docs.whitebit.com/api-reference/account-wallet/overview

Get deposit address for cryptocurrency

```APIDOC
## Get Cryptocurrency Deposit Address

### Description
Get deposit address for cryptocurrency.

### Method
GET

### Endpoint
/api-reference/account-wallet/get-cryptocurrency-deposit-address
```

--------------------------------

### Place a Limit Order (Python)

Source: https://docs.whitebit.com/products/spot/quickstart

Demonstrates how to place a limit order for BTC_USDT using HMAC-SHA512 signing. The order is intentionally set with a price far below market to prevent it from filling, making it safe for testing.

```python
# Place a limit order on BTC_USDT against the live orderbook with HMAC-SHA512 signing.
# The four-step block below uses a price far below market, so the order opens but does not fill — safe for testing without risking a fill.
```

--------------------------------

### Enable Zsh shell completion

Source: https://docs.whitebit.com/guides/cli

Set up Zsh completion by creating a completion file in `~/.zfunc` and updating your `~/.zshrc`.

```bash
mkdir -p ~/.zfunc
whitebit completion --shell zsh > ~/.zfunc/_whitebit
```

--------------------------------

### Get Kill-Switch Status

Source: https://docs.whitebit.com/api-reference/spot-trading/status-kill-switch-timer

Retrieves the status of active kill-switch timers. You can specify a market to get timers for a particular trading pair, or omit the `market` parameter to get timers for all markets.

```APIDOC
## POST /api/v4/order/kill-switch/status

### Description
Retrieves the status of active [kill-switch timers](/glossary#kill-switch-timer). The response returns an array of timer objects for the specified market, or for all markets if the `market` parameter is omitted. Each timer object includes the start time, scheduled cancellation time, and targeted order types.

<Warning>
Rate limit: 10000 requests/10 sec.
</Warning>

<Accordion title="Error Codes">
- `30` - default validation error code
- `31` - market validation failed
</Accordion>

<Accordion title="Errors">
```json
{
  "code": 31,
  "message": "Validation failed",
  "errors": {
    "market": ["Market is not available."]
  }
}
```
</Accordion>

### Method
POST

### Endpoint
/api/v4/order/kill-switch/status

### Parameters
#### Request Body
- **market** (string) - Optional - Available [market](/glossary#market). Example: BTC_USDT
- **request** (string) - Required - Example: '{{request}}'
- **nonce** (string) - Required - Example: '{{nonce}}'

### Request Example
```json
{
  "market": "BTC_USDT",
  "request": "{{request}}",
  "nonce": "{{nonce}}"
}
```

### Response
#### Success Response (200)
- **market** (string) - Trading pair the timer applies to.
- **startTime** (integer) - Unix timestamp (seconds) when the timer was created or last reset.
- **cancellationTime** (integer) - Unix timestamp (seconds) when the kill-switch will cancel orders. Equals `startTime + timeout`.
- **types** (array) - Order types targeted by the kill-switch. Possible values: `spot`, `margin`, `futures`.

#### Response Example
```json
[
  {
    "market": "BTC_USDT",
    "startTime": 1686127243,
    "cancellationTime": 1686127343,
    "types": [
      "spot",
      "margin"
    ]
  }
]
```
```

--------------------------------

### Transfer using 'from' and 'to' fields (recommended)

Source: https://docs.whitebit.com/api-reference/account-wallet/transfer-between-balances

This example shows the recommended way to perform a transfer using the 'from' and 'to' fields to specify the source and destination balances.

```json
{
  "ticker": "XLM",
  "amount": "0.9",
  "from": "main",
  "to": "spot",
  "request": "{{request}}",
  "nonce": "{{nonce}}"
}
```

--------------------------------

### Get Fiat Deposit Address

Source: https://docs.whitebit.com/api-reference/account-wallet/overview

Get deposit address for fiat currency

```APIDOC
## Get Fiat Deposit Address

### Description
Get deposit address for fiat currency.

### Method
GET

### Endpoint
/api-reference/account-wallet/get-fiat-deposit-address
```

--------------------------------

### Subscribe to Balance Updates

Source: https://docs.whitebit.com/guides/account-monitoring

This example demonstrates how to subscribe to real-time spot balance updates using WebSockets. Authentication is required for private channels.

```APIDOC
## Subscribe to Balance Updates

This example assumes an authenticated WebSocket session. Without authentication, the subscription request is rejected.

### Method
WebSocket

### Endpoint
`wss://api.whitebit.com/ws`

### Description
Subscribes to spot balance changes. By default, it subscribes to all assets. You can filter updates by passing specific tickers (e.g., `["USDT", "BTC"]`) in the `params`.

### Request Example
```json
{
  "id": 1,
  "method": "balanceSpot_subscribe",
  "params": []
}
```

### Response Example
```json
{
  "method": "balanceSpot_update",
  "params": {
    "USDT": {"available": "100.0", "freeze": "10.0"},
    "BTC": {"available": "0.5", "freeze": "0.1"}
  }
}
```
```
Tokens:
Raw