Bitget API v3

https://github.com/suenot/bitget-docs-markdown
Admin
Bitget API v3 is a powerful trading platform API that provides programmatic access to spot and...
Tokens:100,670
Snippets:675
Trust Score:9.8
Update:5 months ago
Show doc for...
Tokens:
Raw
### Clone and Install Go SDK

Source: https://github.com/suenot/bitget-docs-markdown/blob/master/docs/sdk/go.md

Clone the SDK repository and install the Go package using go get.

```bash
git clone https://github.com/BitgetLimited/v3-bitget-api-sdk.git
cd v3-bitget-api-sdk/bitget-golang-sdk-api
go get github.com/bitget/bitget-golang-sdk-api
```

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

### REST API Example - Get Account Information

Source: https://github.com/suenot/bitget-docs-markdown/blob/master/docs/sdk/java.md

Demonstrates how to retrieve the user's account information using the initialized Bitget client.

```APIDOC
## REST API Example - Get Account Information

### Description
This example shows how to fetch the current account information, including balances and other relevant details, using the `BitgetClient`.

### Method
`client.spot().getAccountInfo()`

### Endpoint
N/A (Method call on client object)

### Parameters
None

### Request Example
```java
AccountInfo accountInfo = client.spot().getAccountInfo();
```

### Response
#### Success Response (200)
- **accountInfo** (AccountInfo) - An object containing the user'.s account details.

#### Response Example
```json
{
  "accountList": [
    {
      "accountType": "spot",
      "balance": {
        "frozenBalance": "0.00000000",
        "availableBalance": "100.00000000",
        "totalBalance": "100.00000000"
      },
      "currency": "USDT"
    }
  ]
}
```
```

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

### Install SDK via Composer

Source: https://github.com/suenot/bitget-docs-markdown/blob/master/docs/sdk/php.md

Install the Bitget PHP SDK using Composer. Ensure you have Composer installed and configured.

```bash
composer require bitget/bitget-php-sdk-api
```

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

### Clone and Install Python SDK

Source: https://github.com/suenot/bitget-docs-markdown/blob/master/docs/sdk/python.md

Clone the SDK repository and install the necessary Python packages using pip.

```bash
git clone https://github.com/BitgetLimited/v3-bitget-api-sdk.git
cd v3-bitget-api-sdk/bitget-python-sdk-api
```

```bash
pip install requests
pip install websocket-client
```

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

### Install Node.js SDK Dependencies

Source: https://github.com/suenot/bitget-docs-markdown/blob/master/docs/sdk/nodejs.md

Install the necessary dependencies for the Bitget Node.js SDK using npm.

```bash
npm install
```

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

### Clone the Java SDK Repository

Source: https://github.com/suenot/bitget-docs-markdown/blob/master/docs/sdk/java.md

Clone the official Bitget Java SDK repository from GitHub to get started.

```bash
git clone https://github.com/BitgetLimited/v3-bitget-api-sdk.git
cd v3-bitget-api-sdk/bitget-java-sdk-api
```

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

### Install Bitget Python SDK and Dependencies

Source: https://context7.com/suenot/bitget-docs-markdown/llms.txt

This command installs the necessary dependencies for the Bitget Python SDK, including the 'requests' and 'websocket-client' libraries, which are essential for interacting with the Bitget API.

```bash
git clone https://github.com/BitgetLimited/v3-bitget-api-sdk.git
cd v3-bitget-api-sdk/bitget-python-sdk-api
pip install requests websocket-client
```

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

### Start Copy Trading Request Body

Source: https://github.com/suenot/bitget-docs-markdown/blob/master/docs/copy-trading/spot.md

Example request body for initiating copy trading for a specific trader. Requires trader ID, copy amount, quote currency, and copy mode.

```json
{
    "traderId": "123456789",
    "copyAmount": "1000",
    "quoteCoin": "USDT",
    "copyMode": "fixed_amount"
}
```

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

### REST API - Get Account Information

Source: https://github.com/suenot/bitget-docs-markdown/blob/master/docs/sdk/go.md

Example of how to retrieve the user's account information using the Go SDK.

```APIDOC
## GetAccountInfo

### Description
Retrieves the current account information, including balances and other relevant details.

### Method
`client.GetAccountInfo()`

### Parameters
None

### Request Example
```go
// No request body or parameters needed for this call
```

### Response
#### Success Response (200)
Returns the account information.

#### Response Example
```go
// accountInfo object structure
```
```

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

### Initialize REST Client and Get Account Info

Source: https://github.com/suenot/bitget-docs-markdown/blob/master/docs/sdk/nodejs.md

Initialize the SpotClient and retrieve account information.

```javascript
const { SpotClient } = require('bitget-api');

// Initialize client
const client = new SpotClient({
    apiKey: 'your_api_key',
    secretKey: 'your_secret_key',
    passphrase: 'your_passphrase'
});

// Get account information
async function getAccountInfo() {
    try {
        const account = await client.getAccountInfo();
        console.log('Account info:', account);
    } catch (error) {
        console.error('Error getting account info:', error);
    }
}
```

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

### WebSocket Subscription Example

Source: https://github.com/suenot/bitget-docs-markdown/blob/master/docs/rate-limits.md

This example demonstrates how to subscribe to real-time market data updates using the WebSocket API. It shows a typical subscription call for the 'ticker' channel for a specific instrument.

```python
# WebSocket subscription example
ws_client.subscribe([
    {
        "instType": "SPOT",
        "channel": "ticker",
        "instId": "BTCUSDT"
    }
])
```

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

### Error Handling Example

Source: https://github.com/suenot/bitget-docs-markdown/blob/master/docs/sdk/java.md

Provides an example of how to catch and handle specific Bitget API exceptions, including rate limiting and authentication errors.

```APIDOC
## Error Handling Example

### Description
This example demonstrates robust error handling for API calls made using the Bitget SDK. It shows how to catch `BitgetApiException` and differentiate between various error codes, such as rate limits and authentication failures.

### Method
`try-catch` blocks around API calls.

### Parameters
#### Exception Handling
- **BitgetApiException** - Catches API-specific errors.
  - **e.getCode()** - Retrieves the error code.
  - **e.getMessage()** - Retrieves the error message.
- **Exception** - Catches general runtime errors.

### Request Example
```java
try {
    // API call, e.g., PlaceOrderResponse response = client.spot().placeOrder(request);
} catch (BitgetApiException e) {
    switch (e.getCode()) {
        case "00003":
            // Rate limit exceeded
            System.err.println("Rate limit exceeded, implementing backoff...");
            Thread.sleep(1000);
            break;
        case "10001":
            // Authentication error
            System.err.println("Authentication failed, check credentials");
            break;
        default:
            System.err.println("API Error: " + e.getCode() + " - " + e.getMessage());
    }
} catch (Exception e) {
    System.err.println("General error: " + e.getMessage());
}
```
```

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

### REST API Example - Get Ticker Information

Source: https://github.com/suenot/bitget-docs-markdown/blob/master/docs/sdk/java.md

Demonstrates how to retrieve real-time ticker information for a specific trading symbol.

```APIDOC
## REST API Example - Get Ticker Information

### Description
This example shows how to get the latest ticker information for a given trading symbol, including its current price, volume, and other market data.

### Method
`client.spot().getTicker(symbol)`

### Parameters
#### Query Parameters
- **symbol** (String) - Required - The trading pair for which to retrieve ticker information, e.g., "BTCUSDT".

### Request Example
```java
Ticker ticker = client.spot().getTicker("BTCUSDT");
```

### Response
#### Success Response (200)
- **ticker** (Ticker) - An object containing the ticker information.

#### Response Example
```json
{
  "symbol": "BTCUSDT",
  "high24h": "31000.00",
  "low24h": "29000.00",
  "priceChange": "100.00",
  "priceChangePercent": "0.34",
  "last": "30500.00",
  "volume24h": "1000000.00",
  "turnover": "305000000.00"
}
```
```

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

### Initialize REST Client and Get Market Data

Source: https://github.com/suenot/bitget-docs-markdown/blob/master/docs/sdk/nodejs.md

Initialize the SpotClient and fetch the ticker data for BTCUSDT.

```javascript
const { SpotClient } = require('bitget-api');

// Initialize client
const client = new SpotClient({
    apiKey: 'your_api_key',
    secretKey: 'your_secret_key',
    passphrase: 'your_passphrase'
});

// Get market data
async function getMarketData() {
    try {
        const ticker = await client.getTicker('BTCUSDT');
        console.log('Ticker:', ticker);
    } catch (error) {
        console.error('Error getting ticker:', error);
    }
}
```

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

### Spot Copy Trading - Start Copying

Source: https://context7.com/suenot/bitget-docs-markdown/llms.txt

Initiates copy trading for a specified spot trader.

```APIDOC
## POST /api/spot/v1/copytrading/follow

### Description
Initiates copy trading for a specified spot trader.

### Method
POST

### Endpoint
/api/spot/v1/copytrading/follow

### Parameters
#### Request Body
- **traderId** (string) - Required - The ID of the trader to follow.
- **copyAmount** (string) - Required - The amount to copy trade.
- **quoteCoin** (string) - Optional - The quote currency. Defaults to "USDT".
- **copyMode** (string) - Optional - The copy mode. Defaults to "fixed_amount".

### Request Example
```json
{
  "traderId": "123456789",
  "copyAmount": "500",
  "quoteCoin": "USDT",
  "copyMode": "fixed_amount"
}
```

### Response
#### Success Response (200)
- **data** (object)
  - **followId** (string) - The ID of the new copy trading follow.
  - **traderId** (string) - The ID of the trader being followed.
  - **copyAmount** (string) - The amount being copied.
  - **status** (string) - The status of the copy trading relationship.
```

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

### Find Traders and Start Futures Copy Trading

Source: https://context7.com/suenot/bitget-docs-markdown/llms.txt

This Python script demonstrates how to find ranked traders based on specific criteria and programmatically start copy trading with a specified amount and leverage. It requires API credentials and handles the request signing.

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

def get_trader_list(page_size=20, sort_by="profit"):
    resp = requests.get("https://api.bitget.com/api/mix/v1/copytrading/traders",
                         params={"pageSize": page_size, "sortBy": sort_by, "sortType": "desc"})
    traders = resp.json()["data"]["list"]
    # Filter: min 30 days trading, win rate ≥ 60%
    return [t for t in traders
            if int(t["tradingDays"]) >= 30 and float(t["winRate"]) >= 0.6]

def start_copy_trading(api_key, secret_key, passphrase, trader_id,
                        copy_amount, leverage="10"):
    path     = "/api/mix/v1/copytrading/follow"
    body_str = json.dumps({"traderId": trader_id, "copyAmount": copy_amount,
                            "leverage": leverage, "marginMode": "isolated"})
    timestamp = str(int(time.time() * 1000))
    sig = base64.b64encode(
        hmac.new(secret_key.encode(),
                 (timestamp + "POST" + path + body_str).encode(),
                 digestmod="sha256").digest()
    ).decode()
    return requests.post("https://api.bitget.com" + path,
        headers={"ACCESS-KEY": api_key, "ACCESS-SIGN": sig,
                 "ACCESS-TIMESTAMP": timestamp, "ACCESS-PASSPHRASE": passphrase,
                 "Content-Type": "application/json"},
        data=body_str).json()

# Find top traders and distribute $3000 across up to 3
candidates = get_trader_list()[:3]
for trader in candidates:
    result = start_copy_trading(api_key, secret_key, passphrase,
                                 trader["traderId"], "1000")
    print(f"Following {trader['nickName']} (win={trader['winRate']}) → "
          f"followId={result['data']['followId']}")
# Following CryptoMaster (win=0.65) → followId=987654321
```

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

### Get Spot Account Balance - Python

Source: https://context7.com/suenot/bitget-docs-markdown/llms.txt

Get the balance of all assets in the spot account. Filters for assets with non-zero available or frozen balances. Requires authentication.

```python
def get_spot_balance(api_key, secret_key, passphrase):
    path      = "/api/spot/v1/account/assets"
    timestamp = str(int(time.time() * 1000))
    sig = base64.b64encode(
        hmac.new(secret_key.encode(),
                 (timestamp + "GET" + path).encode(),
                 digestmod="sha256").digest()
    ).decode()
    resp = requests.get("https://api.bitget.com" + path,
        headers={"ACCESS-KEY": api_key, "ACCESS-SIGN": sig,
                 "ACCESS-TIMESTAMP": timestamp, "ACCESS-PASSPHRASE": passphrase})
    data = resp.json()["data"]
    # Filter non-zero balances
    return [a for a in data if float(a["available"]) > 0 or float(a["frozen"]) > 0]

balances = get_spot_balance(api_key, secret_key, passphrase)
# [{"coinId":"BTC","available":"1.23456789","frozen":"0.12345678",
#   "btcValue":"1.23456789","usdValue":"45678.12"}]
```

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

### Start Copy Trading

Source: https://github.com/suenot/bitget-docs-markdown/blob/master/docs/copy-trading/spot.md

Initiates copy trading for a specified trader with a given amount and mode.

```APIDOC
## POST /api/spot/v1/copytrading/follow

### Description
Start copying trades from a spot trader.

### Method
POST

### Endpoint
/api/spot/v1/copytrading/follow

### Request Body
- **traderId** (string) - Required - Trader ID to follow.
- **copyAmount** (string) - Required - Amount to use for copy trading.
- **quoteCoin** (string) - Required - Quote currency (e.g., USDT).
- **copyMode** (string) - Required - Copy mode: fixed_amount, fixed_ratio.

### Request Example
```json
{
  "traderId": "123456789",
  "copyAmount": "1000",
  "quoteCoin": "USDT",
  "copyMode": "fixed_amount"
}
```

### Response
#### Success Response (200)
- **code** (string) - Response code
- **msg** (string) - Response message
- **requestTime** (int) - Request timestamp
- **data** (object) - Response data
  - **followId** (string) - Unique identifier for the follow relationship.
  - **traderId** (string) - Trader's unique identifier.
  - **copyAmount** (string) - Amount used for copy trading.
  - **quoteCoin** (string) - Quote currency.
  - **copyMode** (string) - Copy mode.
  - **status** (string) - Status of the copy trading relationship (e.g., active).

### Response Example
```json
{
    "code": "00000",
    "msg": "success",
    "requestTime": 1621441751927,
    "data": {
        "followId": "987654321",
        "traderId": "123456789",
        "copyAmount": "1000",
        "quoteCoin": "USDT",
        "copyMode": "fixed_amount",
        "status": "active"
    }
}
```
```

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

### REST API - Place Order

Source: https://github.com/suenot/bitget-docs-markdown/blob/master/docs/sdk/php.md

Example of placing a limit order on the spot market.

```APIDOC
## POST /api/v3/spot/order

### Description
Places a new order on the spot market.

### Method
POST

### Endpoint
/api/v3/spot/order

### Parameters
#### Request Body
- **symbol** (string) - Required - The trading pair symbol (e.g., BTCUSDT).
- **side** (string) - Required - The order side ('buy' or 'sell').
- **orderType** (string) - Required - The type of order ('limit', 'market', etc.).
- **force** (string) - Required - The order force ('gtc', 'ioc', 'pos').
- **price** (string) - Required for limit orders - The price at which to place the order.
- **quantity** (string) - Required - The quantity of the asset to trade.

### Request Example
```php
$orderParams = [
    'symbol' => 'BTCUSDT',
    'side' => 'buy',
    'orderType' => 'limit',
    'force' => 'gtc',
    'price' => '30000',
    'quantity' => '0.001'
];
$response = $client->spot()->placeOrder($orderParams);
```

### Response
#### Success Response (200)
- **orderId** (string) - The unique identifier for the placed order.
- **status** (string) - The current status of the order.
```

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

### Best Practices - Batch Operations

Source: https://github.com/suenot/bitget-docs-markdown/blob/master/docs/sdk/java.md

Example of performing batch cancellation of orders.

```APIDOC
## Best Practices - Batch Operations

### Description
Illustrates how to efficiently cancel multiple orders simultaneously using the batch cancellation feature, reducing the number of API calls and improving execution speed.

### Code Example
```java
import java.util.List;
import java.util.Arrays;
// Assuming BitgetApiException, BatchCancelOrderRequest, BatchCancelOrderResponse, and BitgetApiClient are available

public class OrderManager {
    private BitgetApiClient client;

    public OrderManager(BitgetApiClient client) {
        this.client = client;
    }

    public void cancelMultipleOrders(List<String> orderIds) {
        try {
            BatchCancelOrderRequest request = BatchCancelOrderRequest.builder()
                .symbol("BTCUSDT")
                .orderIds(orderIds)
                .build();
            BatchCancelOrderResponse response = client.spot().batchCancelOrders(request);
            System.out.println("Orders cancelled: " + response);
        } catch (BitgetApiException e) {
            handleError(e);
        }
    }

    private void handleError(BitgetApiException e) {
        // Implement error handling logic here
        System.err.println("Error cancelling orders: " + e.getMessage());
    }
}
```
```

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

### Futures Copy Trading - Start Copying

Source: https://context7.com/suenot/bitget-docs-markdown/llms.txt

Initiates copy trading for a specified futures trader.

```APIDOC
## POST /api/mix/v1/copytrading/follow

### Description
Initiates copy trading for a specified futures trader.

### Method
POST

### Endpoint
/api/mix/v1/copytrading/follow

### Parameters
#### Request Body
- **traderId** (string) - Required - The ID of the trader to follow.
- **copyAmount** (string) - Required - The amount to copy trade.
- **leverage** (string) - Optional - The leverage to use. Defaults to "10".
- **marginMode** (string) - Optional - The margin mode. Defaults to "isolated".

### Request Example
```json
{
  "traderId": "123456789",
  "copyAmount": "1000",
  "leverage": "10",
  "marginMode": "isolated"
}
```

### Response
#### Success Response (200)
- **data** (object)
  - **followId** (string) - The ID of the new copy trading follow.
```

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

### Best Practices - Connection Pool Management

Source: https://github.com/suenot/bitget-docs-markdown/blob/master/docs/sdk/java.md

Example of managing an OkHttpClient connection pool for efficient network requests.

```APIDOC
## Best Practices - Connection Pool Management

### Description
Demonstrates how to configure and manage an `OkHttpClient` instance to maintain a connection pool, improving performance by reusing connections for multiple HTTP requests.

### Code Example
```java
import okhttp3.OkHttpClient;
import java.util.concurrent.TimeUnit;

public class ConnectionPool {
    private static final OkHttpClient client = new OkHttpClient.Builder()
        .connectTimeout(30, TimeUnit.SECONDS)
        .readTimeout(30, TimeUnit.SECONDS)
        .writeTimeout(30, TimeUnit.SECONDS)
        .build();

    public static OkHttpClient getClient() {
        return client;
    }
}
```
```

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

### REST API - Get Ticker

Source: https://github.com/suenot/bitget-docs-markdown/blob/master/docs/sdk/go.md

Example of how to get the ticker information for a specific trading pair.

```APIDOC
## GetTicker

### Description
Fetches the latest ticker information for a given trading symbol.

### Method
`client.GetTicker(symbol string)`

### Parameters
#### Path Parameters
- **symbol** (string) - Required - The trading symbol (e.g., "BTCUSDT").

### Request Example
```go
ticker, err := client.GetTicker("BTCUSDT")
```

### Response
#### Success Response (200)
Returns the ticker information for the specified symbol.

#### Response Example
```go
// ticker object structure
```
```

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

### REST API Example - Placing an Order

Source: https://github.com/suenot/bitget-docs-markdown/blob/master/docs/sdk/java.md

Demonstrates how to initialize the Bitget client and place a limit order for a spot trading pair.

```APIDOC
## REST API Example - Placing an Order

### Description
This example shows how to initialize the `BitgetClient` with your API credentials and place a limit order on the spot market.

### Method
`client.spot().placeOrder(orderRequest)`

### Parameters
#### Request Body
- **orderRequest** (PlaceOrderRequest) - Required - An object containing the details of the order to be placed.
  - **symbol** (String) - Required - The trading pair, e.g., "BTCUSDT".
  - **side** (String) - Required - The order side, "buy" or "sell".
  - **orderType** (String) - Required - The type of order, e.g., "limit".
  - **force** (String) - Required - The order enforcement, e.g., "gtc" (Good Till Cancelled).
  - **price** (String) - Required - The price at which to place the order.
  - **quantity** (String) - Required - The quantity of the base asset to trade.

### Request Example
```java
PlaceOrderRequest orderRequest = PlaceOrderRequest.builder()
    .symbol("BTCUSDT")
    .side("buy")
    .orderType("limit")
    .force("gtc")
    .price("30000")
    .quantity("0.001")
    .build();

PlaceOrderResponse order = client.spot().placeOrder(orderRequest);
```

### Response
#### Success Response (200)
- **order** (PlaceOrderResponse) - Details of the placed order.

#### Response Example
```json
{
  "orderId": "123456789",
  "symbol": "BTCUSDT",
  "status": "new",
  "price": "30000",
  "quantity": "0.001",
  "side": "buy",
  "orderType": "limit"
}
```
```

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

### Get Mark Price Response

Source: https://github.com/suenot/bitget-docs-markdown/blob/master/docs/futures/market.md

Example JSON response for retrieving the mark price of a contract.

```json
{
    "code": "00000",
    "msg": "success",
    "requestTime": 1621441751927,
    "data": {
        "symbol": "BTCUSDT",
        "markPrice": "30001.00",
        "indexPrice": "30002.00",
        "lastFundingRate": "0.0001",
        "nextFundingTime": 1621441751927
    }
}
```

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

### Initialize REST Client and Place Order

Source: https://github.com/suenot/bitget-docs-markdown/blob/master/docs/sdk/nodejs.md

Initialize the SpotClient and demonstrate how to place a limit order for BTCUSDT.

```javascript
const { SpotClient } = require('bitget-api');

// Initialize client
const client = new SpotClient({
    apiKey: 'your_api_key',
    secretKey: 'your_secret_key',
    passphrase: 'your_passphrase'
});

// Place an order
async function placeOrder() {
    try {
        const order = await client.submitOrder({
            symbol: 'BTCUSDT',
            side: 'buy',
            orderType: 'limit',
            force: 'gtc',
            price: '30000',
            quantity: '0.001'
        });
        console.log('Order placed:', order);
    } catch (error) {
        console.error('Error placing order:', error);
    }
}
```

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

### Initialize and Use Spot REST Client in Go

Source: https://github.com/suenot/bitget-docs-markdown/blob/master/docs/sdk/go.md

Initialize the Spot client with your API credentials and demonstrate placing an order, getting account info, and fetching ticker data.

```go
package main

import (
    "fmt"
    "github.com/bitget/bitget-golang-sdk-api/pkg/client"
    "github.com/bitget/bitget-golang-sdk-api/pkg/model/spot"
)

func main() {
    // Initialize client
    client := client.NewSpotClient(apiKey, secretKey, passphrase)

    // Place an order
    func placeOrder() {
        orderRequest := spot.PlaceOrderRequest{
            Symbol:    "BTCUSDT",
            Side:      "buy",
            OrderType: "limit",
            Force:     "gtc",
            Price:     "30000",
            Quantity:  "0.001",
        }

        response, err := client.PlaceOrder(orderRequest)
        if err != nil {
            fmt.Printf("Error placing order: %v\n", err)
            return
        }
        fmt.Printf("Order placed: %+v\n", response)
    }

    // Get account information
    func getAccountInfo() {
        accountInfo, err := client.GetAccountInfo()
        if err != nil {
            fmt.Printf("Error getting account info: %v\n", err)
            return
        }
        fmt.Printf("Account info: %+v\n", accountInfo)
    }

    // Get market data
    func getMarketData() {
        ticker, err := client.GetTicker("BTCUSDT")
        if err != nil {
            fmt.Printf("Error getting ticker: %v\n", err)
            return
        }
        fmt.Printf("Ticker: %+v\n", ticker)
    }
}
```

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

### Get Index Price Response

Source: https://github.com/suenot/bitget-docs-markdown/blob/master/docs/futures/market.md

Example JSON response for retrieving the index price of a contract.

```json
{
    "code": "00000",
    "msg": "success",
    "requestTime": 1621441751927,
    "data": {
        "symbol": "BTCUSDT",
        "indexPrice": "30002.00",
        "components": [{
            "exchange": "Binance",
            "price": "30001.50",
            "weight": "0.333"
        }]
    }
}
```

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

### Initialize Bitget WebSocket Client

Source: https://github.com/suenot/bitget-docs-markdown/blob/master/docs/sdk/java.md

Set up the BitgetWebSocketClient for real-time data subscriptions. Ensure API keys and passphrase are configured.

```java
import com.bitget.api.ws.BitgetWebSocketClient;
import com.bitget.api.ws.BitgetWebSocketListener;

public class WebSocketExample {
    public static void main(String[] args) {
        BitgetWebSocketClient wsClient = new BitgetWebSocketClient(API_KEY, SECRET_KEY, PASSPHRASE);

        // Create custom listener
        BitgetWebSocketListener listener = new BitgetWebSocketListener() {
            @Override
            public void onMessage(String message) {
                System.out.println("Received message: " + message);
            }

            @Override
            public void onFailure(Throwable t) {
                System.err.println("WebSocket error: " + t.getMessage());
            }

            @Override
            public void onClosing() {
                System.out.println("WebSocket closing");
            }
        };

        // Subscribe to channels
        List<SubscriptionRequest> subscriptions = Arrays.asList(
            new SubscriptionRequest("SPOT", "ticker", "BTCUSDT")
        );

        wsClient.subscribe(subscriptions, listener);
    }
}
```

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

### Place Futures and Spot Orders using Bitget Python SDK

Source: https://context7.com/suenot/bitget-docs-markdown/llms.txt

This Python code demonstrates how to place futures and spot orders using the Bitget SDK. It shows the initialization of order APIs for both futures and spot markets and includes basic error handling for API exceptions.

```python
import bitget.v1.mix.order_api as mix_order
import bitget.v1.spot.order_api as spot_order
import bitget.ws_client as ws_client
from bitget.exceptions import BitgetAPIException

API_KEY, SECRET_KEY, PASSPHRASE = "...", "...", "..."

# --- Futures order ---
futures = mix_order.OrderApi(API_KEY, SECRET_KEY, PASSPHRASE)
try:
    resp = futures.placeOrder({
        "symbol": "BTCUSDT_UMCBL", "marginCoin": "USDT",
        "side": "open_long", "orderType": "limit",
        "price": "30000", "size": "0.01", "timInForceValue": "normal"
    })
    print("Futures order:", resp)
except BitgetAPIException as e:
    print("Error:", e.message)

# --- Spot order ---
spot = spot_order.OrderApi(API_KEY, SECRET_KEY, PASSPHRASE)
try:
    resp = spot.placeOrder({
        "symbol": "BTCUSDT", "side": "buy", "orderType": "limit",
        "force": "gtc", "price": "39000", "quantity": "0.001"
    })
    print("Spot order:", resp)
except BitgetAPIException as e:
    print("Error:", e.message)

# --- WebSocket stream ---
def on_message(msg):
    print("WS msg:", msg)

wsc = ws_client.BitgetWsClient(API_KEY, SECRET_KEY, PASSPHRASE)
wsc.subscribe([{"instType": "SPOT", "channel": "ticker", "instId": "BTCUSDT"}],
               on_message)
wsc.start()
```

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

### Get Trade History Response Structure

Source: https://github.com/suenot/bitget-docs-markdown/blob/master/docs/futures/trading.md

Example JSON response structure for retrieving trade execution history. Includes details like trade ID, order ID, symbol, side, price, size, fee, and creation time.

```json
{
    "code": "00000",
    "msg": "success",
    "requestTime": 1621441751927,
    "data": [{
        "tradeId": "123456789",
        "orderId": "123456789",
        "symbol": "BTCUSDT",
        "side": "buy",
        "price": "30000.00",
        "size": "0.123",
        "fee": "0.00001",
        "feeCurrency": "USDT",
        "role": "maker",
        "createTime": 1621441751927
    }]
}
```

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

### Get Spot Balance

Source: https://context7.com/suenot/bitget-docs-markdown/llms.txt

Get the balance of all assets in the spot account.

```APIDOC
## GET /api/spot/v1/account/assets

### Description
Get the balance of all assets in the spot account.

### Method
GET

### Endpoint
/api/spot/v1/account/assets

### Parameters
No specific parameters are required for this endpoint, but authentication headers are necessary.

### Request Example
```python
def get_spot_balance(api_key, secret_key, passphrase):
    path      = "/api/spot/v1/account/assets"
    timestamp = str(int(time.time() * 1000))
    sig = base64.b64encode(
        hmac.new(secret_key.encode(),
                 (timestamp + "GET" + path).encode(),
                 digestmod="sha256").digest()
    ).decode()
    resp = requests.get("https://api.bitget.com" + path,
        headers={"ACCESS-KEY": api_key, "ACCESS-SIGN": sig,
                 "ACCESS-TIMESTAMP": timestamp, "ACCESS-PASSPHRASE": passphrase})
    data = resp.json()["data"]
    # Filter non-zero balances
    return [a for a in data if float(a["available"]) > 0 or float(a["frozen"]) > 0]
```

### Response
#### Success Response (200)
- **code** (string) - Response code.
- **data** (array) - An array of asset balance objects.
  - **coinId** (string) - The unique identifier for the asset (e.g., BTC).
  - **available** (string) - The available balance of the asset.
  - **frozen** (string) - The frozen balance of the asset.
  - **btcValue** (string) - The value of the asset in BTC.
  - **usdValue** (string) - The value of the asset in USD.

#### Response Example
```json
[
  {
    "coinId":"BTC",
    "available":"1.23456789",
    "frozen":"0.12345678",
    "btcValue":"1.23456789",
    "usdValue":"45678.12"
  }
]
```
```

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

### Initialize Bitget WebSocket Client

Source: https://github.com/suenot/bitget-docs-markdown/blob/master/docs/sdk/php.md

Initialize the Bitget WebSocket client with API credentials and set up message, error, and close handlers.

```php
<?php

require_once 'vendor/autoload.php';

use Bitget\API\WebSocket\BitgetWebSocketClient;

class WebSocketExample {
    private $wsClient;

    public function __construct($apiKey, $secretKey, $passphrase) {
        $this->wsClient = new BitgetWebSocketClient([
            'apiKey' => $apiKey,
            'secretKey' => $secretKey,
            'passphrase' => $passphrase
        ]);

        // Set message handler
        $this->wsClient->onMessage(function($message) {
            echo "Received message: " . $message . "\n";
        });

        // Set error handler
        $this->wsClient->onError(function($error) {
            echo "WebSocket error: " . $error . "\n";
        });

        // Set close handler
        $this->wsClient->onClose(function() {
            echo "WebSocket connection closed\n";
        });
    }

    public function subscribe() {
        $channels = [
            [
                'instType' => 'SPOT',
                'channel' => 'ticker',
                'instId' => 'BTCUSDT'
            ]
        ];

        $this->wsClient->subscribe($channels);
        $this->wsClient->connect();
    }
}

// Usage
$example = new WebSocketExample($apiKey, $secretKey, $passphrase);
$example->subscribe();
```

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

### Margin Trading API Response Example

Source: https://github.com/suenot/bitget-docs-markdown/blob/master/docs/spot/margin.md

This is an example of a successful response from the margin trading API, detailing order information.

```json
{
    "code": "00000",
    "msg": "success",
    "requestTime": 1621441751927,
    "data": [{
        "orderId": "123456789",
        "coinId": "BTC",
        "amount": "0.5",
        "liquidationPrice": "25000.00",
        "status": "completed",
        "createTime": 1621441751927
    }]
}
```

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

### Configure API Credentials in Java

Source: https://github.com/suenot/bitget-docs-markdown/blob/master/docs/sdk/java.md

Set up your Bitget API key, secret key, and passphrase for authentication.

```java
String apiKey = "your_api_key";
String secretKey = "your_secret_key";
String passphrase = "your_passphrase";
```

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

### REST API - Place Order

Source: https://github.com/suenot/bitget-docs-markdown/blob/master/docs/sdk/go.md

Example of how to place a limit order for a spot trading pair using the Go SDK.

```APIDOC
## PlaceOrder

### Description
Places a limit order for a specified trading pair.

### Method
`client.PlaceOrder(request spot.PlaceOrderRequest)`

### Parameters
#### Request Body
- **Symbol** (string) - Required - The trading pair symbol (e.g., "BTCUSDT").
- **Side** (string) - Required - The order side ('buy' or 'sell').
- **OrderType** (string) - Required - The type of order ('limit', 'market', etc.).
- **Force** (string) - Required - The order enforcement type ('gtc', 'ioc', 'pos').
- **Price** (string) - Required - The price at which to place the order.
- **Quantity** (string) - Required - The quantity of the asset to trade.

### Request Example
```go
orderRequest := spot.PlaceOrderRequest{
    Symbol:    "BTCUSDT",
    Side:      "buy",
    OrderType: "limit",
    Force:     "gtc",
    Price:     "30000",
    Quantity:  "0.001",
}
```

### Response
#### Success Response (200)
Returns the details of the placed order.

#### Response Example
```go
// response object structure
```
```

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

### Initialize Bitget REST Client

Source: https://github.com/suenot/bitget-docs-markdown/blob/master/docs/sdk/java.md

Instantiate the BitgetClient with your API credentials to interact with the Bitget REST API.

```java
import com.bitget.api.client.BitgetClient;
import com.bitget.api.model.spot.*;

public class BitgetExample {
    private static final String API_KEY = "your_api_key";
    private static final String SECRET_KEY = "your_secret_key";
    private static final String PASSPHRASE = "your_passphrase";

    public static void main(String[] args) {
        // Initialize client
        BitgetClient client = new BitgetClient(API_KEY, SECRET_KEY, PASSPHRASE);

        try {
            // Place an order
            PlaceOrderRequest orderRequest = PlaceOrderRequest.builder()
                .symbol("BTCUSDT")
                .side("buy")
                .orderType("limit")
                .force("gtc")
                .price("30000")
                .quantity("0.001")
                .build();

            PlaceOrderResponse order = client.spot().placeOrder(orderRequest);
            System.out.println("Order placed: " + order);

            // Get account information
            AccountInfo accountInfo = client.spot().getAccountInfo();
            System.out.println("Account info: " + accountInfo);

            // Get market data
            Ticker ticker = client.spot().getTicker("BTCUSDT");
            System.out.println("Ticker: " + ticker);

        } catch (BitgetApiException e) {
            System.err.println("API Error: " + e.getCode() + " - " + e.getMessage());
        } catch (Exception e) {
            System.err.println("Error: " + e.getMessage());
        }
    }
}
```

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

### Establish WebSocket Connection (JavaScript)

Source: https://github.com/suenot/bitget-docs-markdown/blob/master/docs/spot/ws-user.md

Initializes a WebSocket connection to the Bitget Spot API stream. This is the first step in establishing a private data stream.

```javascript
const ws = new WebSocket('wss://ws.bitget.com/spot/v1/stream');
```

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

### Place a Spot Order

Source: https://github.com/suenot/bitget-docs-markdown/blob/master/docs/sdk/php.md

Example of placing a limit order on the spot market. Ensure you have sufficient balance and correct parameters.

```php
// Place an order
$orderParams = [
    'symbol' => 'BTCUSDT',
    'side' => 'buy',
    'orderType' => 'limit',
    'force' => 'gtc',
    'price' => '30000',
    'quantity' => '0.001'
];

$response = $client->spot()->placeOrder($orderParams);
echo "Order placed: " . json_encode($response, JSON_PRETTY_PRINT) . "\n";
```

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

### Configure API Credentials

Source: https://github.com/suenot/bitget-docs-markdown/blob/master/docs/sdk/nodejs.md

Set up your API key, secret key, and passphrase for authentication with the Bitget API.

```javascript
const apiKey = 'your_api_key';
const secretKey = 'your_secret_key';
const passphrase = 'your_passphrase';
```

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

### Get Order History

Source: https://context7.com/suenot/bitget-docs-markdown/llms.txt

Retrieve historical orders filtered by time range.

```APIDOC
## GET /api/spot/v1/trade/history

### Description
Retrieve historical orders filtered by time range.

### Method
GET

### Endpoint
/api/spot/v1/trade/history

### Parameters
#### Query Parameters
- **symbol** (string) - Required - The trading pair symbol (e.g., BTCUSDT).
- **limit** (string) - Optional - The maximum number of orders to retrieve.

### Request Example
```bash
curl -H "ACCESS-KEY: ..." -H "ACCESS-SIGN: ..." -H "ACCESS-TIMESTAMP: ..." \
     -H "ACCESS-PASSPHRASE: ..." \
     "https://api.bitget.com/api/spot/v1/trade/history?symbol=BTCUSDT&limit=2"
```

### Response
#### Success Response (200)
- **code** (string) - Response code.
- **data** (array) - An array of historical order objects.
  - **orderId** (string) - The unique identifier for the order.
  - **symbol** (string) - The trading pair symbol.
  - **price** (string) - The price of the order.
  - **quantity** (string) - The quantity of the order.
  - **executedQty** (string) - The executed quantity.
  - **side** (string) - The side of the order ('buy' or 'sell').
  - **status** (string) - The status of the order (e.g., 'filled').
  - **fee** (string) - The trading fee.
  - **feeCoin** (string) - The currency in which the fee was paid.
  - **createTime** (integer) - The timestamp when the order was created.

#### Response Example
```json
{
  "code":"00000",
  "data":[
    {
      "orderId":"123456789",
      "symbol":"BTCUSDT",
      "price":"39000.5",
      "quantity":"0.1",
      "executedQty":"0.1",
      "side":"buy",
      "status":"filled",
      "fee":"3.9",
      "feeCoin":"USDT",
      "createTime":1621441751927
    }
  ]
}
```
```

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

### Get Current Positions

Source: https://github.com/suenot/bitget-docs-markdown/blob/master/docs/copy-trading/futures.md

Retrieves the current open positions for copy trading.

```APIDOC
## GET /api/mix/v1/copytrading/positions

### Description
Get current copy trading positions.

### Method
GET

### Endpoint
/api/mix/v1/copytrading/positions

### Parameters
#### Query Parameters
- **followId** (string) - Required - Follow ID

### Response
#### Success Response (200)
- **code** (string) - Response code
- **msg** (string) - Response message
- **requestTime** (long) - Request timestamp
- **data** (array) - List of current positions
  - **symbol** (string) - Trading symbol
  - **side** (string) - Position side (long/short)
  - **size** (string) - Position size
  - **entryPrice** (string) - Entry price
  - **markPrice** (string) - Current mark price
  - **unrealizedPnl** (string) - Unrealized Profit and Loss
  - **leverage** (string) - Leverage used
  - **marginMode** (string) - Margin mode (e.g., isolated, cross)
  - **createTime** (long) - Position creation time

### Request Example
GET /api/mix/v1/copytrading/positions?followId=123

### Response Example
```json
{
    "code": "00000",
    "msg": "success",
    "requestTime": 1621441751927,
    "data": [
        {
            "symbol": "BTCUSDT",
            "side": "long",
            "size": "0.1",
            "entryPrice": "30000.50",
            "markPrice": "31000.50",
            "unrealizedPnl": "100.00",
            "leverage": "10",
            "marginMode": "isolated",
            "createTime": 1621441751927
        }
    ]
}
```
```

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

### Get Copy Trading History

Source: https://github.com/suenot/bitget-docs-markdown/blob/master/docs/copy-trading/futures.md

Retrieves the history of copied trades for the user.

```APIDOC
## GET /api/mix/v1/copytrading/history

### Description
Get history of copied trades.

### Method
GET

### Endpoint
/api/mix/v1/copytrading/history

### Parameters
#### Query Parameters
(No specific parameters are documented in the source for this endpoint. Pagination and filtering parameters might be available but are not explicitly listed.)

### Response
#### Success Response (200)
(The response structure for this endpoint is not detailed in the provided source.)
```

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

### Configure API Credentials in Go

Source: https://github.com/suenot/bitget-docs-markdown/blob/master/docs/sdk/go.md

Define your API key, secret key, and passphrase as constants for authentication.

```go
const (
    apiKey     = "your_api_key"
    secretKey  = "your_secret_key"
    passphrase = "your_passphrase"
)
```

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

### Get Order History

Source: https://github.com/suenot/bitget-docs-markdown/blob/master/docs/futures/trading.md

Retrieve historical futures orders for a given symbol.

```APIDOC
## GET /api/mix/v1/order/history

### Description
Get historical orders.

### Method
GET

### Endpoint
/api/mix/v1/order/history

### Parameters
#### Path Parameters
N/A

#### Query Parameters
- **symbol** (string) - Required - Contract symbol
- **limit** (int) - Optional - Number of records to retrieve (default: 100, max: 500)
- **startTime** (integer) - Optional - Start time for filtering history (Unix timestamp in milliseconds)
- **endTime** (integer) - Optional - End time for filtering history (Unix timestamp in milliseconds)

#### Request Body
N/A

### Request Example
N/A (Use query parameters)

### Response
#### Success Response (200)
- **code** (string) - Response code
- **msg** (string) - Response message
- **requestTime** (integer) - Request timestamp
- **data** (array) - Array of historical order objects. The structure is similar to the 'Get Open Orders' response.

#### Response Example
```json
{
    "code": "00000",
    "msg": "success",
    "requestTime": 1621441751927,
    "data": [
        {
            "orderId": "123456789",
            "symbol": "BTCUSDT",
            "side": "buy",
            "orderType": "limit",
            "price": "30000.50",
            "size": "0.123",
            "filledSize": "0.123",
            "avgPrice": "30000.50",
            "leverage": "10",
            "marginMode": "isolated",
            "status": "filled",
            "createTime": 1621441751927,
            "updateTime": 1621441751927
        }
    ]
}
```
```

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

### Initialize and Use WebSocket Client in Go

Source: https://github.com/suenot/bitget-docs-markdown/blob/master/docs/sdk/go.md

Initialize the WebSocket client and subscribe to market data channels like ticker, books, trade, and candle. A message handler processes incoming messages.

```go
package main

import (
    "fmt"
    "github.com/bitget/bitget-golang-sdk-api/pkg/client/ws"
    "github.com/bitget/bitget-golang-sdk-api/pkg/model/ws"
)

func main() {
    // Initialize WebSocket client
    wsClient := ws.NewWebSocketClient(apiKey, secretKey, passphrase)

    // Define message handler
    messageHandler := func(message string) {
        fmt.Printf("Received message: %s\n", message)
    }

    // Subscribe to channels
    subscriptions := []ws.SubscriptionRequest{
        {
            InstType: "SPOT",
            Channel:  "ticker",
            InstId:   "BTCUSDT",
        },
    }

    wsClient.Subscribe(subscriptions, messageHandler)

    // Keep the connection alive
    select {}
}
```

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

### Start Copy Trading Request

Source: https://github.com/suenot/bitget-docs-markdown/blob/master/docs/copy-trading/futures.md

Initiates copy trading for a specified trader. Requires trader ID, copy amount, leverage, and margin mode.

```json
{
    "code": "00000",
    "msg": "success",
    "requestTime": 1621441751927,
    "data": {
        "followId": "987654321",
        "traderId": "123456789",
        "copyAmount": "1000",
        "leverage": "10",
        "marginMode": "isolated",
        "status": "active"
    }
}
```
Tokens:
Raw