REST Open API v1.0.0

Scroll down for code samples, example requests and responses. Select a language for code samples from the tabs above or the mobile navigation menu.

Base URLs:

• https://api.binance.th

General Info

General API Information

• The base endpoint is: https://api.binance.th
• All endpoints return either a JSON object or array.
• Data is returned in ascending order. Oldest first, newest last.
• All time and timestamp related fields are in milliseconds.

HTTP Return Codes

• HTTP 4XX return codes are used for malformed requests; the issue is on the sender's side.
• HTTP 403 return code is used when the WAF Limit (Web Application Firewall) has been violated.
• HTTP 429 return code is used when breaking a request rate limit.
• HTTP 418 return code is used when an IP has been auto-banned for continuing to send requests after receiving 429 codes.
• HTTP 5XX return codes are used for internal errors; the issue is on server side. It is important to NOT treat this as a failure operation; the execution status is UNKNOWN and could have been a success.

Response fields description

General Information on Endpoints

• For GET endpoints, parameters must be sent as a query string.
• For POST endpoints, the parameters may be sent as a query string or in the request body with content type application/x-www-form-urlencoded. You may mix parameters between both the query string and request body if you wish to do so.
• Parameters may be sent in any order.
• If a parameter sent in both the query string and request body, the body string parameter will be used.

LIMITS

General Info on Limits

• The following intervalLetter values for headers:
  • SECOND => S
  • MINUTE => M
  • HOUR => H
  • DAY => D
• intervalNum describes the amount of the interval. For example, intervalNum 5 with intervalLetter M means "Every 5 minutes".
• A 429 will be returned when either rate limit is violated.

IP Limits

• Every request will contain X-MBX-USED-WEIGHT-(intervalNum)(intervalLetter) in the response headers which has the current used weight for the IP for all request rate limiters defined.
• Each route has a weight which determines for the number of requests each endpoint counts for. Heavier endpoints and endpoints that do operations on multiple symbols will have a heavier weight.
• When a 429 is received, it's your obligation as an API to back off and not spam the API.
• Repeatedly violating rate limits and/or failing to back off after receiving 429s will result in an automated IP ban (HTTP status 418).
• IP bans are tracked and scale in duration for repeat offenders, from 2 minutes to 3 days.
• A Retry-After header is sent with a 418 or 429 responses and will give the number of seconds required to wait, in the case of a 418, to prevent a ban, or, in the case of a 429, until the ban is over.
• The limits on the API are based on the IPs, not the API keys.

We recommend using the websocket for getting data as much as possible, as this will not count to the request rate limit.

Order Rate Limits

• Every successful order response will contain a X-MBX-ORDER-COUNT-(intervalNum)(intervalLetter) header which has the current order count for the account for all order rate limiters defined.
• Rejected/unsuccessful orders are not guaranteed to have X-MBX-ORDER-COUNT-** headers in the response.
• The order rate limit is counted against each account.

Endpoint security type

• Each endpoint has a security type that determines the how you will interact with it. This is stated next to the NAME of the endpoint.
  • If no security type is stated, assume the security type is NONE.
• API-keys are passed into the Rest API via the X-MBX-APIKEY header.
• API-keys and secret-keys are case sensitive.
• API-keys can be configured to only access certain types of secure endpoints. For example, one API-key could be used for SIGNED only, while another API-key can access everything except for SIGNED routes.
• By default, API-keys can access all secure routes.

SIGNED Endpoint security

• SIGNED endpoints require an additional parameter, signature, to be sent in the query string or request body.
• Endpoints use HMAC SHA256 signatures. The HMAC SHA256 signature is a keyed HMAC SHA256 operation. Use your secretKey as the key and totalParams as the value for the HMAC operation.
• The signature is not case sensitive.
• totalParams is defined as the query string concatenated with the request body.

Timing security

• A SIGNED endpoint also requires a parameter, timestamp, to be sent which should be the millisecond timestamp of when the request was created and sent.
• An additional parameter, recvWindow, may be sent to specify the number of milliseconds after timestamp the request is valid for. If recvWindow is not sent, it defaults to 5000.
• The logic is as follows:

The logic is as follows:

if (timestamp < (serverTime + 1000) && (serverTime - timestamp) <= recvWindow) {
  // process request
} else {
  // reject request
}

Serious trading is about timing. Networks can be unstable and unreliable, which can lead to requests taking varying amounts of time to reach the servers. With recvWindow, you can specify that the request must be processed within a certain number of milliseconds or be rejected by the server.

It is recommended to use a small recvWindow of 5000 or less! The max cannot go beyond 60,000!

SIGNED Endpoint Examples for POST /api/v1/order

Here is a step-by-step example of how to send a vaild signed payload from the Linux command line using echo, openssl, and curl.

Example 1: As a request body

• requestBody:

symbol=LTCBTC
&side=BUY
&type=LIMIT
&timeInForce=GTC
&quantity=1
&price=0.1
&recvWindow=5000
&timestamp=1499827319559

Example 1: HMAC SHA256 signature:

[linux]$ echo -n "symbol=LTCBTC&side=BUY&type=LIMIT&timeInForce=GTC&quantity=1&price=0.1&recvWindow=5000&timestamp=1499827319559" | openssl dgst -sha256 -hmac "NhqPtmdSJYdKjVHjA7PZj4Mge3R5YNiP1e3UZjInClVN65XAbvqqM6A7H5fATj0j"
(stdin)= c8db56825ae71d6d79447849e617115f4a920fa2acdcab2b053c4b2838bd6b71

Example 1: curl command:

(HMAC SHA256)
[linux]$ curl -H "X-MBX-APIKEY: vmPUZE6mv9SD5VNHk4HlWFsOr6aKE2zvsw0MuIgwCIPy6utIco14y7Ju91duEh8A" -X POST 'https://api.binance.th/api/v1/order' -d 'symbol=LTCBTC&side=BUY&type=LIMIT&timeInForce=GTC&quantity=1&price=0.1&recvWindow=5000&timestamp=1499827319559&signature=c8db56825ae71d6d79447849e617115f4a920fa2acdcab2b053c4b2838bd6b71'

Example 2: As a query string

• queryString:

symbol=LTCBTC
&side=BUY
&type=LIMIT
&timeInForce=GTC
&quantity=1
&price=0.1
&recvWindow=5000
&timestamp=1499827319559

Example 2: HMAC SHA256 signature:

[linux]$ echo -n "symbol=LTCBTC&side=BUY&type=LIMIT&timeInForce=GTC&quantity=1&price=0.1&recvWindow=5000&timestamp=1499827319559" | openssl dgst -sha256 -hmac "NhqPtmdSJYdKjVHjA7PZj4Mge3R5YNiP1e3UZjInClVN65XAbvqqM6A7H5fATj0j"
(stdin)= c8db56825ae71d6d79447849e617115f4a920fa2acdcab2b053c4b2838bd6b71

Example 2: curl command:

(HMAC SHA256)
[linux]$ curl -H "X-MBX-APIKEY: vmPUZE6mv9SD5VNHk4HlWFsOr6aKE2zvsw0MuIgwCIPy6utIco14y7Ju91duEh8A" -X POST 'https://api.binance.th/api/v1/order?symbol=LTCBTC&side=BUY&type=LIMIT&timeInForce=GTC&quantity=1&price=0.1&recvWindow=5000&timestamp=1499827319559&signature=c8db56825ae71d6d79447849e617115f4a920fa2acdcab2b053c4b2838bd6b71'

Example 3: Mixed query string and request body

• queryString:

symbol=LTCBTC
&side=BUY
&type=LIMIT
&timeInForce=GTC

• requestBody:

quantity=1&price=0.1&recvWindow=5000&timestamp=1499827319559

Example 3: HMAC SHA256 signature:

[linux]$ echo -n "symbol=LTCBTC&side=BUY&type=LIMIT&timeInForce=GTCquantity=1&price=0.1&recvWindow=5000&timestamp=1499827319559" | openssl dgst -sha256 -hmac "NhqPtmdSJYdKjVHjA7PZj4Mge3R5YNiP1e3UZjInClVN65XAbvqqM6A7H5fATj0j"
(stdin)= 0fd168b8ddb4876a0358a8d14d0c9f3da0e9b20c5d52b2a00fcf7d1c602f9a77

curl command:

(HMAC SHA256)
[linux]$ curl -H "X-MBX-APIKEY: vmPUZE6mv9SD5VNHk4HlWFsOr6aKE2zvsw0MuIgwCIPy6utIco14y7Ju91duEh8A" -X POST 'https://api.binance.th/api/v1/order?symbol=LTCBTC&side=BUY&type=LIMIT&timeInForce=GTC' -d 'quantity=1&price=0.1&recvWindow=5000&timestamp=1499827319559&signature=0fd168b8ddb4876a0358a8d14d0c9f3da0e9b20c5d52b2a00fcf7d1c602f9a77'

Note that the signature is different in example 3. There is no & between "GTC" and "quantity=1".

Public API Definitions

Terminology

• base asset refers to the asset that is the quantity of a symbol.
• quote asset refers to the asset that is the price of a symbol.

ENUM definitions

Order status (status):

Order types (orderTypes, type):

• LIMIT
• MARKET
• STOP_LOSS
• STOP_LOSS_LIMIT
• TAKE_PROFIT
• TAKE_PROFIT_LIMIT
• LIMIT_MAKER

Order Response Type (newOrderRespType):

• ACK
• RESULT
• FULL

Order side (side):

• BUY
• SELL

Time in force (timeInForce, for LIMIT, STOP_LOSS_LIMIT, TAKE_PROFIT_LIMIT):

Kline/Candlestick chart intervals:

m -> minutes; h -> hours; d -> days; w -> weeks; M -> months

• 1m
• 3m
• 5m
• 15m
• 30m
• 1h
• 2h
• 4h
• 6h
• 8h
• 12h
• 1d
• 3d
• 1w
• 1M

Rate limiters (rateLimitType)

• REQUEST_WEIGHT

• ORDERS

• RAW_REQUESTS

Rate limit intervals (interval)

• SECOND
• MINUTE
• DAY

Filters

Filters define trading rules on a symbol or an exchange. Filters come in two forms: symbol filters and exchange filters.

Symbol Filters

PRICE_FILTER

The PRICE_FILTER defines the price rules for a symbol. There are 3 parts:

• minPrice defines the minimum price/stopPrice allowed; disabled on minPrice == 0.
• maxPrice defines the maximum price/stopPrice allowed; disabled on maxPrice == 0.
• tickSize defines the intervals that a price/stopPrice can be increased/decreased by; disabled on tickSize == 0.

Any of the above variables can be set to 0, which disables that rule in the price filter. In order to pass the price filter, the following must be true for price/stopPrice of the enabled rules:

• price >= minPrice
• price <= maxPrice
• (price-minPrice) % tickSize == 0

/exchangeInfo format:

{
  "filterType": "PRICE_FILTER",
  "minPrice": "0.00000100",
  "maxPrice": "100000.00000000",
  "tickSize": "0.00000100"
}

PERCENT_PRICE

The PERCENT_PRICE filter defines valid range for a price based on the average of the previous trades. avgPriceMins is the number of minutes the average price is calculated over. 0 means the last price is used.

In order to pass the percent price, the following must be true for price:

• price <= weightedAveragePrice * multiplierUp
• price >= weightedAveragePrice * multiplierDown

/exchangeInfo format:

{
  "filterType": "PERCENT_PRICE",
  "multiplierUp": "1.3000",
  "multiplierDown": "0.7000",
  "avgPriceMins": 5
}

LOT_SIZE

The LOT_SIZE filter defines the quantity (aka "lots" in auction terms) rules for a symbol. There are 3 parts:

• minQty defines the minimum quantity allowed.
• maxQty defines the maximum quantity allowed.
• stepSize defines the intervals that a quantity can be increased/decreased by.

In order to pass the lot size, the following must be true for quantity:

• quantity >= minQty
• quantity <= maxQty
• (quantity-minQty) % stepSize == 0

/exchangeInfo format:

{
  "filterType": "LOT_SIZE",
  "minQty": "0.00100000",
  "maxQty": "100000.00000000",
  "stepSize": "0.00100000"
}

MIN_NOTIONAL

The MIN_NOTIONAL filter defines the minimum notional value allowed for an order on a symbol. An order's notional value is the price * quantity. applyToMarket determines whether or not the MIN_NOTIONAL filter will also be applied to MARKET orders. Since MARKET orders have no price, the average price is used over the last avgPriceMins minutes. avgPriceMins is the number of minutes the average price is calculated over. 0 means the last price is used.

/exchangeInfo format:

{
  "filterType": "MIN_NOTIONAL",
  "minNotional": "0.00100000",
  "applyToMarket": true,
  "avgPriceMins": 5
}

MARKET_LOT_SIZE

The MARKET_LOT_SIZE filter defines the quantity (aka "lots" in auction terms) rules for MARKET orders on a symbol. There are 3 parts:

• minQty defines the minimum quantity allowed.
• maxQty defines the maximum quantity allowed.
• stepSize defines the intervals that a quantity can be increased/decreased by.

In order to pass the market lot size, the following must be true for quantity:

• quantity >= minQty
• quantity <= maxQty
• (quantity-minQty) % stepSize == 0

/exchangeInfo format:

{
  "filterType": "MARKET_LOT_SIZE",
  "minQty": "0.00100000",
  "maxQty": "100000.00000000",
  "stepSize": "0.00100000"
}

MAX_NUM_ORDERS

The MAX_NUM_ORDERS filter defines the maximum number of orders an account is allowed to have open on a symbol. Note that both "algo" orders and normal orders are counted for this filter.

/exchangeInfo format:

{
  "filterType": "MAX_NUM_ORDERS",
  "limit": 25
}

MAX_NUM_ALGO_ORDERS(*)

The MAX_NUM_ALGO_ORDERS filter defines the maximum number of "algo" orders an account is allowed to have open on a symbol. "Algo" orders are STOP_LOSS, STOP_LOSS_LIMIT, TAKE_PROFIT, and TAKE_PROFIT_LIMIT orders.

/exchangeInfo format:

{
  "filterType": "MAX_NUM_ALGO_ORDERS",
  "maxNumAlgoOrders": 5
}

Exchange Filters

EXCHANGE_MAX_NUM_ORDERS

The MAX_NUM_ORDERS filter defines the maximum number of orders an account is allowed to have open on the exchange. Note that both "algo" orders and normal orders are counted for this filter.

EXCHANGE_MAX_NUM_ALGO_ORDERS(*)

The MAX_ALGO_ORDERS filter defines the maximum number of "algo" orders an account is allowed to have open on the exchange. "Algo" orders are STOP_LOSS, STOP_LOSS_LIMIT, TAKE_PROFIT, and TAKE_PROFIT_LIMIT orders.

Tips

The above are marked with "(*)" may NOT be supported by SITE symbols.

Best Practice Guide

This guide focuses on integration patterns and operational best practices. For complete endpoint definitions, refer to the API Reference section.

1. Getting Started: Account & API Key Setup

Creating Your Account

1. Sign Up: Register for a Binance TH account using the mobile application or at https://www.binance.th
2. Complete Identity Verification: Complete the Know Your Customer (KYC) or Know Your Business (KYB) verification process before accessing trading and API functionality.

Funding Your Account

Before using trading APIs, ensure your account has sufficient balance.

Deposit Fiat (THB)

1. Open the Wallet section in the Binance TH application
2. Select Deposit
3. Choose THB
4. Follow the instructions to deposit funds from your bank account

Deposit Digital Assets

1. Open the Wallet section
2. Select Deposit
3. Choose the desired cryptocurrency
4. Follow the instructions to transfer funds from another exchange or wallet

API Key Generation

1. Login: Access your Binance TH account on the web
2. Click your user icon in the top-right corner and select API Management
3. Enter a name for your API key (for example: Example Trading Bot) and click Create API
4. Pass the two-factor authentication (2FA) prompt
5. Your API key will now be generated. Store the key and secret securely.
6. Click Edit Restrictions to configure additional security settings such as IP address whitelisting.

API Key Security

Follow these best practices to secure your API keys:

• Store Securely: Never share your API keys or secrets
• Use Separate Keys: Create different keys for different applications or services
• Limit Permissions: Grant only the permissions required for your use case
• Monitor Usage: Regularly review API activity and permissions

API Authentication Types

Security Type Configuration:

• NONE: Public endpoints (no authentication required)
• USER_STREAM: Requires API Key only
• SIGNED: Requires an API Key and a request signature generated using your API Secret.

Permission Scopes:

Configure API keys with the minimal permissions required for your application.

• Read-only: For market data and account information queries
• Trading: For placing and managing orders

Additional Security Best Practices

• IP Whitelisting (Recommended): Restrict API key usage to specific IP addresses
• Key Rotation: Rotate API keys regularly (recommended every 90 days)
• Environment Separation: Use different API keys for development, staging, and production environments

Storage Best Practices

2. Authentication & Signing (CRITICAL)

Understanding SIGNED Endpoints

SIGNED endpoints require:

• X-MBX-APIKEY header containing your API key
• timestamp parameter (milliseconds since Unix epoch)
• signature parameter (HMAC SHA256 hash)
• Optional recvWindow parameter (default: 5000ms, max: 60000ms)

Signature Generation Formula

The signature is calculated using HMAC SHA256:

signature = HMAC_SHA256(secretKey, totalParams)

Where:

• secretKey: Your API secret key
• totalParams: Query string + Request body concatenated

Step-by-Step Signature Process

1. Construct the Parameter String

For Query String Only:

symbol=BTCTHB&side=BUY&type=LIMIT&timeInForce=GTC&quantity=0.1&price=1000000&recvWindow=5000&timestamp=1499827319559

For Mixed Query + Body (NO & between sections):

Query: symbol=BTCTHB&side=BUY&type=LIMIT&timeInForce=GTC
Body: quantity=0.1&price=1000000&recvWindow=5000&timestamp=1499827319559
Concatenated: symbol=BTCTHB&side=BUY&type=LIMIT&timeInForce=GTCquantity=0.1&price=1000000&recvWindow=5000&timestamp=1499827319559

2. Generate HMAC SHA256 Hash

Java Example:

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.StandardCharsets;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.stream.Collectors;

public class SignatureGenerator {

    public static String generateSignature(String secretKey, Map<String, String> params)
            throws Exception {
        // Build parameter string
        String paramString = params.entrySet().stream()
            .map(entry -> entry.getKey() + "=" + entry.getValue())
            .collect(Collectors.joining("&"));

        // Generate HMAC SHA256
        Mac sha256_HMAC = Mac.getInstance("HmacSHA256");
        SecretKeySpec secret_key = new SecretKeySpec(
            secretKey.getBytes(StandardCharsets.UTF_8),
            "HmacSHA256"
        );
        sha256_HMAC.init(secret_key);

        byte[] hash = sha256_HMAC.doFinal(paramString.getBytes(StandardCharsets.UTF_8));

        // Convert to hex string
        StringBuilder hex = new StringBuilder();
        for (byte b : hash) {
            hex.append(String.format("%02x", b));
        }
        return hex.toString();
      }

    // Usage example
    public static void main(String[] args) throws Exception {
        String apiSecret = "YOUR_SECRET_KEY";
        long timestamp = System.currentTimeMillis();

        Map<String, String> params = new LinkedHashMap<>();
        params.put("symbol", "BTCTHB");
        params.put("side", "BUY");
        params.put("type", "LIMIT");
        params.put("timeInForce", "GTC");
        params.put("quantity", "0.1");
        params.put("price", "1000000");
        params.put("recvWindow", "5000");
        params.put("timestamp", String.valueOf(timestamp));

        String signature = generateSignature(apiSecret, params);
        System.out.println("Signature: " + signature);
    }
}

Timestamp Drift Handling

The server validates timestamps using this logic:

if (timestamp < (serverTime + 1000) && (serverTime - timestamp) <= recvWindow) {
  // Request accepted
} else {
  // Request rejected with -1021 error
}

Best Practices:

1. Synchronize System Time with NTP Server

   • Linux/Mac: Use ntpdate or chrony
   • Windows: Enable Windows Time service
   • Cloud servers: Verify NTP is configured correctly

2. Query Server Time Periodically

   • Call GET /api/v1/time on application startup
   • Calculate offset between local and server time
   • Refresh offset every 30-60 minutes
   • Apply offset to all subsequent timestamp generation

3. Account for Network Latency

   • Measure round-trip time to API servers
   • Consider using timestamp slightly earlier than current time for high-latency networks
   • Increase recvWindow only when necessary (not as default solution)

Java Implementation:

import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import org.json.JSONObject;

public class TimestampManager {
    private long timeOffset = 0;
    private long lastSync = 0;
    private static final long SYNC_INTERVAL = 3600000; // 1 hour in milliseconds
    private final HttpClient httpClient = HttpClient.newHttpClient();

    public void syncTime() throws Exception {
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.binance.th/api/v1/time"))
            .GET()
            .build();

        HttpResponse<String> response = httpClient.send(
            request,
            HttpResponse.BodyHandlers.ofString()
        );

        JSONObject json = new JSONObject(response.body());
        long serverTime = json.getLong("serverTime");
        long localTime = System.currentTimeMillis();

        this.timeOffset = serverTime - localTime;
        this.lastSync = localTime;
    }

    public long getTimestamp() throws Exception {
        long currentTime = System.currentTimeMillis();

        // Resync if needed
        if ((currentTime - lastSync) > SYNC_INTERVAL) {
            syncTime();
        }

        return currentTime + timeOffset;
    }
}

recvWindow Best Practice

The recvWindow parameter defines how long a request remains valid after the timestamp.

Recommendations:

Common Authentication Failures

Error -1021: Timestamp outside recvWindow

Causes & Solutions:

Important: Never cache or reuse timestamps across multiple requests.

Error -1022: Invalid signature

Common Causes:

1. Incorrect parameter ordering when mixing query string and request body
2. URL encoding issues: Sign the original parameter values, not URL-encoded ones
3. Case sensitivity: Secret keys and API keys are case-sensitive
4. Including signature in signed data: The signature parameter must NOT be included in the string being signed
5. Character encoding: Ensure UTF-8 encoding for all strings
6. Whitespace: Trim any leading/trailing whitespace from parameter values

Debugging Steps:

1. Print the exact parameter string being signed
2. Verify parameter order matches request
3. Check for URL encoding issues
4. Confirm secret key is correct and case-sensitive
5. Test with known working examples from documentation

Error -2015: Invalid API key

Causes:

• API key not properly set in X-MBX-APIKEY header
• API key revoked or expired
• IP address not whitelisted (if IP restriction enabled)
• API key lacks required permissions for the endpoint
• Extra whitespace in API key header value

3. Market Data Flow

Overview: How to Read the Market

The recommended flow for consuming market data:

1. GET /api/v1/exchangeInfo → Understand symbols, filters, and trading rules
2. Subscribe to WebSocket depth stream → Receive real-time updates
3. GET /api/v1/depth → Get initial orderbook snapshot
4. Maintain local orderbook → Apply updates correctly
5. Monitor trade/ticker streams → Track price movements
6. Use REST for recovery → Resync on disconnect

Step 1: Get Exchange Information

Purpose: Understand available trading pairs, filters, and rules before trading.

Key Information to Extract:

Call GET /api/v1/exchangeInfo and extract:

• Symbol Status: Check if status is TRADING (not BREAK or HALT)
• Symbol Type: GLOBAL (supports all features) vs SITE (limited features)
• Filters: Price limits, lot sizes, minimum notional values
• Order Types: Supported order types for the symbol
• Precision: Base and quote asset precision

Critical Filters:

Best Practice: Cache exchange info for 1 hour, refresh periodically to catch any trading rule updates.

Step 2: Subscribe to Orderbook Stream

WebSocket Endpoints:

• Standard updates (1000ms): wss://nbstream.binance.th/w3w/wsa/stream?<symbol>@depth
• Fast updates (100ms): wss://nbstream.binance.th/w3w/wsa/stream?<symbol>@depth@100ms

Diff Depth Stream Structure:

{
  "e": "depthUpdate",
  "E": 1672515782136,
  "s": "BTCTHB",
  "U": 157,
  "u": 160,
  "b": [["1000000.00", "0.5"]],
  "a": [["1001000.00", "0.3"]]
}

Important: Quantity of 0 means remove price level from the orderbook.

Step 3: Maintain Local Orderbook

Correct Synchronization Process:

1. Subscribe to WebSocket stream first (buffer incoming messages)
2. Get snapshot via REST: GET /api/v1/depth?symbol=BTCTHB&limit=1000
3. Drop all events where u (final update ID) ≤ snapshot's lastUpdateId
4. Verify first event: Must have U ≤ lastUpdateId + 1 AND u ≥ lastUpdateId + 1
5. Apply subsequent updates: Each update's U should equal previous u + 1
6. Handle gaps: If U ≠ previous_u + 1, resync immediately

Update Rules:

• If quantity = 0: Remove price level
• If quantity > 0 and price exists: Update quantity
• If quantity > 0 and price doesn't exist: Add new price level

Data Structure Recommendations:

• Use sorted map/tree structure for bids (descending) and asks (ascending)
• Maintain separate collections for bids and asks
• Store last update ID for gap detection
• Implement automatic resync on gap detection

Step 4: Monitor Trades and Ticker for Pricing

Stream Options:

Recommendations:

• For price discovery: Use trade stream to see actual execution prices
• For spread monitoring: Use book ticker stream (lighter than full depth)
• For market statistics: Use 24hr ticker stream
• For multiple symbols: Use combined streams or all-market streams

Rate Limit Consideration: WebSocket streams do NOT count toward REST API rate limits. Prefer WebSocket over polling REST endpoints.

4. Trading Flow

Overview: Place → Monitor → Reconcile

1. Retrieve symbol filters from exchangeInfo
2. Validate and format order parameters
3. Submit order with proper authentication
4. Listen to user data stream for real-time updates
5. Reconcile with REST API if needed

Step 1: Get Symbol Filters and Format Order

Filter Validation Rules:

Price Filter:

price >= minPrice
price <= maxPrice
(price - minPrice) % tickSize == 0

Lot Size Filter:

quantity >= minQty
quantity <= maxQty
(quantity - minQty) % stepSize == 0

Min Notional Filter:

price × quantity >= minNotional

Best Practice: Always round DOWN to comply with filters, never round up.

Precision Handling:

• Use decimal/BigDecimal types (not float/double) for financial calculations
• Round to step size BEFORE submitting order
• Validate all constraints before sending to API

Step 2: Send Order

Order Parameters:

Order Response Types:

• ACK: Fastest, minimal response (only acknowledgment)
• RESULT: Returns order status immediately after placement
• FULL: Returns complete execution details (recommended for production)

Best Practices:

1. Use newClientOrderId: Enables order tracking and idempotency
2. Set newOrderRespType to FULL: Get complete execution details
3. Validate locally first: Check filters before submitting to avoid rejections
4. Handle rate limits: Monitor X-MBX-ORDER-COUNT-* headers
5. Use appropriate order types:
   • LIMIT: For price control
   • MARKET: For immediate execution (subject to slippage)
   • STOP_LOSS_LIMIT: For stop orders with price protection

Step 3: Listen to User Data Stream for Execution

User Data Stream Setup:

1. Create ListenKey: POST /api/v1/listenKey
2. Connect WebSocket: wss://nbstream.binance.th/w3w/wsa/stream?streams={listenKey}
3. Keep-alive: PUT /api/v1/listenKey every 30 minutes
4. Close when done: DELETE /api/v1/listenKey

Event Types:

Order Status Flow:

NEW → PARTIALLY_FILLED → FILLED
NEW → CANCELED
NEW → REJECTED
NEW → EXPIRED

Key Fields in executionReport:

• X: Current order status (NEW, FILLED, PARTIALLY_FILLED, CANCELED, REJECTED)
• i: Order ID
• c: Client order ID
• z: Cumulative filled quantity
• L: Last executed price
• l: Last executed quantity
• n: Commission amount
• N: Commission asset

Best Practice: Store order updates in database with event time and update ID for audit trail.

Step 4: Reconcile Using REST if WebSocket Disconnects

Reconciliation Scenarios:

1. WebSocket disconnect: Query all open orders and recent trades
2. Missed updates: Check order status by ID
3. Periodic verification: Reconcile every few minutes as safety check

Reconciliation Endpoints:

Reconciliation Strategy:

1. On disconnect: Immediately query open orders for active symbols
2. Match by client order ID: Use origClientOrderId parameter for tracking
3. Verify fills: Cross-check with trade history if needed
4. Update local state: Sync all order statuses and balances

Important: Always reconcile after WebSocket reconnection to ensure no updates were missed.

5. Wallet / Balance Logic

Understanding Available vs Locked Balance

Balance Structure (GET /api/v1/accountV2):

{
  "asset": "BTC",
  "free": "0.5",
  "locked": "0.1"
}

Balance States:

Total Balance: total = free + locked

When Balance Updates After Trades

Balance Update Sequence:

1. Order Placement: - SELL order: Base asset moves from free to locked - BUY order: Quote asset moves from free to locked

2. Order Execution: - Sold asset: locked decreases - Bought asset: free increases (minus commission) - Commission: Deducted from received asset

3. Order Cancellation: - Remaining locked amount returns to free

Example Flow:

Initial: BTC free=1.0, locked=0.0

1. Place SELL 0.5 BTC @ 1,000,000 THB:
   BTC free=0.5, locked=0.5

2. Filled 0.3 BTC:
   BTC free=0.5, locked=0.2
   THB free=+300,000 (minus commission)

3. Cancel order:
   BTC free=0.7, locked=0.0
   (0.2 BTC returned from canceled portion)

User Data Stream Events:

• outboundAccountPosition: Contains the assets that were possibly changed by the event that generated the balance change (sent after any balance change)
• balanceUpdate: Specific balance delta with reason

Best Practice:

• Listen to WebSocket for real-time balance updates
• Query GET /api/v1/accountV2 for periodic reconciliation
• Never rely solely on calculated balances; always verify with API

How to Track Transfers

Deposit Tracking:

• Endpoint: GET /api/v1/capital/deposit/history
• Monitor status: 0=pending, 6=credited, 1=failed
• Use startTime and endTime for specific periods
• Check txId for blockchain verification

Withdrawal Tracking:

• Endpoint: GET /api/v1/capital/withdraw/history
• Monitor status: 0=pending, 6=completed, 4=failed
• Withdrawals deduct from free balance immediately
• Failed withdrawals return funds to free balance

Transfer Best Practices:

1. Poll periodically: Check every 1-5 minutes for deposit confirmations
2. Handle blockchain delays: Crypto deposits require network confirmations
3. Verify txId: Cross-check with blockchain explorers for crypto transfers
4. Reconcile balances: After deposits/withdrawals, verify account balance matches expectations

6. How to Withdraw

Initiating a Withdrawal

• Endpoint: POST /api/v1/capital/withdraw
• Requires SIGNED request
• Funds are deducted from free balance immediately

Tracking Withdrawal Status

• Endpoint: GET /api/v1/capital/withdraw/history
• Status values:
  • 0 = Email Sent
  • 1 = Cancelled
  • 2 = Awaiting Approval
  • 3 = Rejected
  • 4 = Processing
  • 5 = Failure
  • 6 = Completed

Withdrawal Best Practices

• Always validate address and network before submitting
• Monitor withdrawal status until completion
• Handle failures and retries carefully
• Reconcile balance after withdrawal

7. Rate Limits & Throughput Management

Understanding Weight-Based Rate Limits

The API uses a weight-based rate limiting system. Each endpoint has an assigned weight, and your total consumed weight is tracked per IP address.

IP Rate Limits:

How Weights Work:

• Each endpoint consumes a specific weight per call (e.g., GET /api/v1/time = weight 1)
• Heavier endpoints and multi-symbol queries consume more weight
• All requests from the same IP share the same weight pool, regardless of API key

Example Weight Costs:

Order Rate Limits

Order rate limits are tracked separately per account (not per IP).

• Every successful order response includes X-MBX-ORDER-COUNT-(intervalNum)(intervalLetter) headers showing your current order count
• Rejected or unsuccessful orders are not guaranteed to include these headers
• Exceeding the order rate limit returns HTTP 429

Monitoring Rate Limit Headers

Every API response includes headers to help you track your usage:

IP Weight Headers:

X-MBX-USED-WEIGHT-10S: 42     # Weight used in current 10-second window
X-MBX-USED-WEIGHT-1M: 358     # Weight used in current 1-minute window

Order Count Headers (on order responses):

X-MBX-ORDER-COUNT-10S: 3      # Orders placed in current 10-second window
X-MBX-ORDER-COUNT-1D: 47      # Orders placed in current day window

Best Practices:

1. Read these headers on every response and track usage in your application
2. Set internal thresholds at ~80% of the limit to trigger throttling before hitting the actual limit
3. Log limit usage for capacity planning and debugging

IP Ban Behavior

Repeated rate limit violations escalate from temporary throttling to IP bans:

Ban Escalation:

• Bans are tracked and scale in duration for repeat offenders
• Range: 2 minutes to 3 days depending on violation history
• Both 429 and 418 responses include a Retry-After header (in seconds)

Backpressure Design

Design your application to handle rate limits gracefully rather than hitting them:

1. Request Budgeting:

• Calculate the total weight of your polling loop per cycle
• Ensure your cycle fits within the 10-second and 1-minute windows
• Leave headroom for ad-hoc requests (order placement, queries)

2. Request Prioritization:

• Assign priority levels to API calls (e.g., order placement > market data polling > historical queries)
• When approaching limits, drop or defer low-priority requests first

3. Use a Rate Limiter / Token Bucket:

• Implement a token bucket or sliding window counter in your client
• Deduct the endpoint weight from your budget before every request
• Queue or delay requests when the budget is exhausted

4. Prefer WebSocket Over Polling:

5. Batch Where Possible:

• Use combined WebSocket streams (?streams=stream1/stream2/stream3) instead of separate connections
• Query multiple symbols in a single exchangeInfo call instead of per-symbol requests

8. Failure & Retry Best Practices

What to Do on -1021 Timestamp Error

Error Message:

{
  "code": -1021,
  "msg": "Timestamp for this request is outside of the recvWindow."
}

Resolution Steps:

1. Immediate Action: Sync time with server

   • Call GET /api/v1/time
   • Calculate offset: serverTime - localTime
   • Apply offset to all subsequent requests

2. System-Level Fix:

   • Verify NTP is running and synchronized
   • Check system time zone is correct
   • Restart NTP daemon if necessary

3. Application-Level Fix:

   • Implement automatic time sync on startup
   • Refresh offset every hour
   • Never cache timestamps across requests

4. Last Resort: Increase recvWindow (but not beyond 60000ms)

Prevention:

• Implement time sync manager (see code examples in section 2)
• Monitor system clock drift
• Alert on repeated timestamp errors

How to Retry on Network Timeout

Retry Strategy:

Exponential Backoff: - 1st retry: 1 second - 2nd retry: 2 seconds - 3rd retry: 4 seconds - 4th retry: 8 seconds - Max delay: 32 seconds

HTTP Status Codes to Retry:

Do NOT Retry:

• 400: Bad request (fix parameters)
• 401: Unauthorized (check API key)
• 403: Forbidden (WAF violation, stop immediately)
• 418: IP banned

Best Practices:

1. Check Retry-After header: Honor rate limit backoff times
2. Add jitter: Random delay prevents thundering herd
3. Circuit breaker: Stop retrying after repeated failures
4. Log retry attempts: Track patterns for debugging
5. Alert on repeated failures: Investigate systematic issues

Idempotency Considerations

Use Client Order IDs:

• Parameter: newClientOrderId
• Format: Unique string up to 36 characters
• Recommendation: Use UUID or timestamp-based ID

Benefits:

1. Duplicate prevention: Same client order ID won't create duplicate orders
2. Order tracking: Query orders by your ID instead of exchange ID
3. Retry safety: Safely retry order placement on timeout

Query by Client Order ID:

GET /api/v1/order?symbol=BTCTHB&origClientOrderId=YOUR_CLIENT_ID

Idempotent Retry Flow:

1. Generate unique clientOrderId
2. Submit order with clientOrderId
3. On timeout:
   a. Query order by clientOrderId
   b. If exists: Order was placed successfully
   c. If not exists: Safe to retry with same clientOrderId
4. On network error:
   a. Retry with same clientOrderId
   b. Exchange prevents duplicate if first attempt succeeded

Best Practice: Always use client order IDs for production trading systems.

WebSocket Connection Lifecycle

Base Endpoint:

Binance TH uses a single WebSocket endpoint for all symbols:

wss://nbstream.binance.th/w3w/wsa/stream

Streams are accessed via query parameter: ?streams=<streamName1>/<streamName2>

Connection Limits:

Ping/Pong Behavior:

• The server sends a ping frame every 3 minutes
• If the server does not receive a pong frame within 10 minutes, the connection is disconnected
• Unsolicited pong frames are allowed (you can send pong frames proactively)

Symbol Stream Names:

All symbols in stream names must be lowercase (e.g., btcthb@depth, not BTCTHB@depth).

WebSocket Reconnect Logic

Reconnection Strategy:

1. Exponential Backoff: - Initial reconnect: Immediate - 1st failure: 5 seconds - 2nd failure: 10 seconds - 3rd failure: 20 seconds - Max delay: 60 seconds

2. User Data Stream Keep-Alive: - Ping every 30 minutes: PUT /api/v1/listenKey - If ping fails: Create new listen key and reconnect - Close old listen key after successful reconnection

3. Market Data Stream Reconnection: - Depth stream: Get new snapshot and resync orderbook - Trade stream: No reconciliation needed (real-time only) - Ticker stream: No reconciliation needed

WebSocket Best Practices:

1. Buffer messages during snapshot: Don't drop updates during sync
2. Implement heartbeat: Send ping frames to keep connection alive
3. Handle connection state: Track connecting, connected, disconnecting, disconnected
4. Automatic recovery: Reconnect without manual intervention
5. Alert on repeated failures: Monitor connection stability

Connection Health Monitoring:

• Track connection uptime
• Count reconnection attempts
• Monitor message latency
• Alert on degraded performance

For additional code examples, language-specific SDKs, and implementation guides, please refer to the separate code samples documentation.

General Endpoints

Check Server Time

Code samples

# You can also use wget
curl -X GET https://api.binance.th/api/v1/time \
  -H 'Accept: application/json'

GET https://api.binance.th/api/v1/time HTTP/1.1
Host: api.binance.th
Accept: application/json

const headers = {
  Accept: "application/json",
};

fetch("https://api.binance.th/api/v1/time", {
  method: "GET",

  headers: headers,
})
  .then(function (res) {
    return res.json();
  })
  .then(function (body) {
    console.log(body);
  });

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get 'https://api.binance.th/api/v1/time',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('https://api.binance.th/api/v1/time', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','https://api.binance.th/api/v1/time', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.binance.th/api/v1/time");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.binance.th/api/v1/time", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/v1/time

Test connectivity to the Rest API and get the current server time.

Weight(IP): 1

Example responses

200 Response

{ "serverTime": 1655374964469 }

Responses

Response Schema

Execution Rules

Code samples

# You can also use wget
curl -X GET https://api.binance.th/api/v1/executionRules \
  -H 'Accept: application/json'

GET https://api.binance.th/api/v1/executionRules HTTP/1.1
Host: api.binance.th
Accept: application/json

const headers = {
  Accept: "application/json",
};

fetch("https://api.binance.th/api/v1/executionRules", {
  method: "GET",

  headers: headers,
})
  .then(function (res) {
    return res.json();
  })
  .then(function (body) {
    console.log(body);
  });

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get 'https://api.binance.th/api/v1/executionRules',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('https://api.binance.th/api/v1/executionRules', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','https://api.binance.th/api/v1/executionRules', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.binance.th/api/v1/executionRules");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.binance.th/api/v1/executionRules", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/v1/executionRules

Query execution rules for a symbol or all symbols.

Weight(IP): 1

Parameters

Example responses

200 Response

{
  "symbolRules": [
    {
      "symbol": "BAZUSD",
      "rules": [
        {
          "ruleType": "PRICE_RANGE",
          "bidMultiplierUp": "2.0000",
          "bidMultiplierDown": "0.5000",
          "askMultiplierUp": "2.0000",
          "askMultiplierDown": "0.5000"
        }
      ]
    }
  ]
}

Responses

Response Schema

Exchange Information

Code samples

# You can also use wget
curl -X GET https://api.binance.th/api/v1/exchangeInfo \
  -H 'Accept: application/json' \
  -H 'X-MBX-APIKEY: API_KEY'

GET https://api.binance.th/api/v1/exchangeInfo HTTP/1.1
Host: api.binance.th
Accept: application/json

const headers = {
  Accept: "application/json",
  "X-MBX-APIKEY": "API_KEY",
};

fetch("https://api.binance.th/api/v1/exchangeInfo", {
  method: "GET",

  headers: headers,
})
  .then(function (res) {
    return res.json();
  })
  .then(function (body) {
    console.log(body);
  });

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-MBX-APIKEY' => 'API_KEY'
}

result = RestClient.get 'https://api.binance.th/api/v1/exchangeInfo',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'X-MBX-APIKEY': 'API_KEY'
}

r = requests.get('https://api.binance.th/api/v1/exchangeInfo', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
    'X-MBX-APIKEY' => 'API_KEY',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','https://api.binance.th/api/v1/exchangeInfo', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.binance.th/api/v1/exchangeInfo");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "X-MBX-APIKEY": []string{"API_KEY"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.binance.th/api/v1/exchangeInfo", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/v1/exchangeInfo

Current exchange trading rules and symbol information.

Weight(IP): 10

Example responses

200 Response

{
  "timezone": "UTC",
  "serverTime": 1565246363776,
  "rateLimits": [{}],
  "exchangeFilters": [],
  "symbols": [
    {
      "symbol": "ETHBTC",
      "status": "TRADING",
      "baseAsset": "ETH",
      "baseAssetPrecision": 8,
      "quoteAsset": "BTC",
      "quotePrecision": 8,
      "quoteAssetPrecision": 8,
      "baseCommissionPrecision": 8,
      "quoteCommissionPrecision": 8,
      "type": "GLOBAL",
      "orderTypes": [
        "LIMIT",
        "LIMIT_MAKER",
        "MARKET",
        "STOP_LOSS_LIMIT",
        "TAKE_PROFIT_LIMIT"
      ],
      "filters": []
    }
  ]
}

Responses

Response Schema

Reference Price

Code samples

# You can also use wget
curl -X GET https://api.binance.th/api/v1/referencePrice \
  -H 'Accept: application/json'

GET https://api.binance.th/api/v1/referencePrice HTTP/1.1
Host: api.binance.th
Accept: application/json

const headers = {
  Accept: "application/json",
};

fetch("https://api.binance.th/api/v1/referencePrice", {
  method: "GET",

  headers: headers,
})
  .then(function (res) {
    return res.json();
  })
  .then(function (body) {
    console.log(body);
  });

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get 'https://api.binance.th/api/v1/referencePrice',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('https://api.binance.th/api/v1/referencePrice', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','https://api.binance.th/api/v1/referencePrice', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.binance.th/api/v1/referencePrice");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.binance.th/api/v1/referencePrice", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/v1/referencePrice

Query the reference price for a symbol or all symbols.

Weight(IP): 1

Parameters

Example responses

200 Response

{
  "symbol": "BAZUSD",
  "referencePrice": "10.00",
  "timestamp": 1770736694138
}

Responses

Response Schema

Check Symbol Type

Code samples

# You can also use wget
curl -X GET https://api.binance.th/api/v1/symbolType \
  -H 'Accept: application/json'

GET https://api.binance.th/api/v1/symbolType HTTP/1.1
Host: api.binance.th
Accept: application/json

const headers = {
  Accept: "application/json",
};

fetch("https://api.binance.th/api/v1/symbolType", {
  method: "GET",

  headers: headers,
})
  .then(function (res) {
    return res.json();
  })
  .then(function (body) {
    console.log(body);
  });

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get 'https://api.binance.th/api/v1/symbolType',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('https://api.binance.th/api/v1/symbolType', headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','https://api.binance.th/api/v1/symbolType', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.binance.th/api/v1/symbolType");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.binance.th/api/v1/symbolType", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/v1/symbolType

Check Symbol Type, type will be GLOBAL or SITE.

Weight(IP): 1

Parameters

Example responses

200 Response

[
  { "symbol": "BTCBUSD", "type": "GLOBAL" },
  { "symbol": "BTCUSDT", "type": "SITE" }
]

Responses

Response Schema

Market Data Endpoints

Symbol Order Book Ticker

Code samples

# You can also use wget
curl -X GET https://api.binance.th/api/v1/ticker/bookTicker?symbol=string \
  -H 'Accept: application/json'

GET https://api.binance.th/api/v1/ticker/bookTicker?symbol=string HTTP/1.1
Host: api.binance.th
Accept: application/json

const headers = {
  Accept: "application/json",
};

fetch("https://api.binance.th/api/v1/ticker/bookTicker?symbol=string", {
  method: "GET",

  headers: headers,
})
  .then(function (res) {
    return res.json();
  })
  .then(function (body) {
    console.log(body);
  });

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get 'https://api.binance.th/api/v1/ticker/bookTicker',
  params: {
  'symbol' => 'string'
}, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('https://api.binance.th/api/v1/ticker/bookTicker', params={
  'symbol': 'string'
}, headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','https://api.binance.th/api/v1/ticker/bookTicker', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.binance.th/api/v1/ticker/bookTicker?symbol=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.binance.th/api/v1/ticker/bookTicker", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/v1/ticker/bookTicker

Best price/qty on the order book for a symbol or symbols.

Weight(IP): 1

Parameters

Example responses

200 Response

{
  "symbol": "ETHBTC",
  "bidPrice": "0.07946700",
  "bidQty": "9.00000000",
  "askPrice": "100000.00000000",
  "askQty": "1000.00000000"
}

Responses

Response Schema

Kline/Candlestick Data

Code samples

# You can also use wget
curl -X GET https://api.binance.th/api/v1/klines?symbol=string&interval=string \
  -H 'Accept: application/json'

GET https://api.binance.th/api/v1/klines?symbol=string&interval=string HTTP/1.1
Host: api.binance.th
Accept: application/json

const headers = {
  Accept: "application/json",
};

fetch("https://api.binance.th/api/v1/klines?symbol=string&interval=string", {
  method: "GET",

  headers: headers,
})
  .then(function (res) {
    return res.json();
  })
  .then(function (body) {
    console.log(body);
  });

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get 'https://api.binance.th/api/v1/klines',
  params: {
  'symbol' => 'string',
'interval' => 'string'
}, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('https://api.binance.th/api/v1/klines', params={
  'symbol': 'string',  'interval': 'string'
}, headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','https://api.binance.th/api/v1/klines', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.binance.th/api/v1/klines?symbol=string&interval=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.binance.th/api/v1/klines", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/v1/klines

Kline/candlestick bars for a symbol. Klines are uniquely identified by their open time.

Weight(IP): 1

Response ordered oldest to newest.

Parameters

Example responses

200 Response

[
  [
    1499040000000,      // Open time
    "0.01634790",       // Open
    "0.80000000",       // High
    "0.01575800",       // Low
    "0.01577100",       // Close
    "148976.11427815",  // Volume
    1499644799999,      // Close time
    "2434.19055334",    // Quote asset volume
    308,                // Number of trades
    "1756.87402397",    // Taker buy base asset volume
    "28.46694368"       // Taker buy quote asset volume,
    "0"
  ]
]

Responses

Response Schema

24hr Ticker Price Change Statistics

Code samples

# You can also use wget
curl -X GET https://api.binance.th/api/v1/ticker/24hr?symbol=string \
  -H 'Accept: application/json'

GET https://api.binance.th/api/v1/ticker/24hr?symbol=string HTTP/1.1
Host: api.binance.th
Accept: application/json

const headers = {
  Accept: "application/json",
};

fetch("https://api.binance.th/api/v1/ticker/24hr?symbol=string", {
  method: "GET",

  headers: headers,
})
  .then(function (res) {
    return res.json();
  })
  .then(function (body) {
    console.log(body);
  });

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get 'https://api.binance.th/api/v1/ticker/24hr',
  params: {
  'symbol' => 'string'
}, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('https://api.binance.th/api/v1/ticker/24hr', params={
  'symbol': 'string'
}, headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','https://api.binance.th/api/v1/ticker/24hr', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.binance.th/api/v1/ticker/24hr?symbol=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.binance.th/api/v1/ticker/24hr", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/v1/ticker/24hr

24 hour rolling window price change statistics.

Weight(IP): 1

Parameters

Example responses

200 Response

{
  "symbol": "BNBBTC",
  "priceChange": "-94.99999800",
  "priceChangePercent": "-95.960",
  "weightedAvgPrice": "0.29628482",
  "prevClosePrice": "0.10002000",
  "lastPrice": "4.00000200",
  "lastQty": "200.00000000",
  "bidPrice": "4.00000000",
  "bidQty": "100.00000000",
  "askPrice": "4.00000200",
  "askQty": "100.00000000",
  "openPrice": "99.00000000",
  "highPrice": "100.00000000",
  "lowPrice": "0.10000000",
  "volume": "8913.30000000",
  "quoteVolume": "15.30000000",
  "openTime": 1499783499040,
  "closeTime": 1499869899040,
  "firstId": 28385,
  "lastId": 28460,
  "count": 76
}

Responses

Response Schema

Order Book

Code samples

# You can also use wget
curl -X GET https://api.binance.th/api/v1/depth?symbol=string \
  -H 'Accept: application/json'

GET https://api.binance.th/api/v1/depth?symbol=string HTTP/1.1
Host: api.binance.th
Accept: application/json

const headers = {
  Accept: "application/json",
};

fetch("https://api.binance.th/api/v1/depth?symbol=string", {
  method: "GET",

  headers: headers,
})
  .then(function (res) {
    return res.json();
  })
  .then(function (body) {
    console.log(body);
  });

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get 'https://api.binance.th/api/v1/depth',
  params: {
  'symbol' => 'string'
}, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('https://api.binance.th/api/v1/depth', params={
  'symbol': 'string'
}, headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','https://api.binance.th/api/v1/depth', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.binance.th/api/v1/depth?symbol=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.binance.th/api/v1/depth", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/v1/depth

Get Order Book.

Weight(IP):

Adjusted based on the limit:

Parameters

Detailed descriptions

symbol: The symbol of the currency to query. Check Symbol Type(GET /api/v1/symbolType)

limit: Default 500; max 1000. If limit > 1000, then the response will truncate to 1000.

Example responses

200 Response

{
  "lastUpdateId": 1027024,
  "bids": [["4.00000000", "431.00000000"]],
  "asks": [["4.00000200", "12.00000000"]]
}

Responses

Response Schema

Recent Trades List

Code samples

# You can also use wget
curl -X GET https://api.binance.th/api/v1/trades?symbol=string \
  -H 'Accept: application/json'

GET https://api.binance.th/api/v1/trades?symbol=string HTTP/1.1
Host: api.binance.th
Accept: application/json

const headers = {
  Accept: "application/json",
};

fetch("https://api.binance.th/api/v1/trades?symbol=string", {
  method: "GET",

  headers: headers,
})
  .then(function (res) {
    return res.json();
  })
  .then(function (body) {
    console.log(body);
  });

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get 'https://api.binance.th/api/v1/trades',
  params: {
  'symbol' => 'string'
}, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('https://api.binance.th/api/v1/trades', params={
  'symbol': 'string'
}, headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','https://api.binance.th/api/v1/trades', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.binance.th/api/v1/trades?symbol=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://api.binance.th/api/v1/trades", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /api/v1/trades

Get recent trades.

Weight(IP): 1

Parameters

Detailed descriptions

symbol: The symbol of the currency to query. Check Symbol Type(GET /api/v1/symbolType)

Example responses

200 Response

[
  {
    "id": 28457,
    "price": "4.00000100",
    "qty": "12.00000000",
    "quoteQty": "48.000012",
    "time": 1499865549590,
    "isBuyerMaker": true,
    "isBestMatch": true
  }
]

Responses

Response Schema

Compressed/Aggregate Trades List

Code samples

# You can also use wget
curl -X GET https://api.binance.th/api/v1/aggTrades?symbol=string \
  -H 'Accept: application/json'

GET https://api.binance.th/api/v1/aggTrades?symbol=string HTTP/1.1
Host: api.binance.th
Accept: application/json

const headers = {
  Accept: "application/json",
};

fetch("https://api.binance.th/api/v1/aggTrades?symbol=string", {
  method: "GET",

  headers: headers,
})
  .then(function (res) {
    return res.json();
  })
  .then(function (body) {
    console.log(body);
  });

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json'
}

result = RestClient.get 'https://api.binance.th/api/v1/aggTrades',
  params: {
  'symbol' => 'string'
}, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json'
}

r = requests.get('https://api.binance.th/api/v1/aggTrades', params={
  'symbol': 'string'
}, headers = headers)

print(r.json())

<?php

require 'vendor/autoload.php';

$headers = array(
    'Accept' => 'application/json',
);

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','https://api.binance.th/api/v1/aggTrades', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

URL obj = new URL("https://api.binance.th/api/v1/aggTrades?symbol=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());