repository·master·Indexed 25 days ago
https://github.com/binance/binance-connector-pythonA collection of auto-generated Python SDKs for various Binance APIs, including Spot, Futures, and Margin trading. It provides modular, service-specific packages such as binance-sdk-algo, binance-sdk-alpha, binance-sdk-c2c, binance-sdk-convert, binance-sdk-copy-trading, and binance-sdk-crypto-loan. These SDKs require Python 3.10 or later and utilize binance-common for shared types and utilities.
This SDK enables programmatic interaction with Binance's COIN-M Futures API through three distinct communication methods:
/dapi/* endpoints.The Binance Python SPOT SDK allows developers to interact programmatically with the Binance SPOT trading platform. It provides access to three main interaction methods:
/api/* endpoints.The library includes test cases and examples to assist with onboarding.
The Binance Python Derivatives Trading (USDS-M Futures) SDK provides programmatic access to Binance's USDS-M Futures API through three primary interfaces:
/fapi/* endpoints.The SDK includes test cases and examples to assist with onboarding.
The Binance Python Connectors repository provides modular SDKs for various Binance services. Each is available as a separate PyPI package:
binance-sdk-algo: Algo Tradingbinance-sdk-alpha: Alphabinance-sdk-c2c: C2Cbinance-sdk-convert: Convertbinance-sdk-copy-trading: Copy Tradingbinance-sdk-crypto-loan: Crypto Loanbinance-sdk-derivatives-trading-coin-futures: Coin Futures Tradingbinance-sdk-derivatives-trading-options: Options Tradingbinance-sdk-derivatives-trading-portfolio-margin: Portfolio Margin Futures Tradingbinance-sdk-derivatives-trading-portfolio-margin-pro: Portfolio Margin Pro Tradingbinance-sdk-derivatives-trading-usds-futures: USDs Futures Tradingbinance-sdk-dual-investment: Dual Investmentbinance-sdk-fiat: Fiatbinance-sdk-gift-card: Gift Cardbinance-sdk-margin-trading: Margin Tradingbinance-sdk-mining: Miningbinance-sdk-pay: Paybinance-sdk-rebate: Rebatebinance-sdk-simple-earn: Simple Earnbinance-sdk-spot: Spot Tradingbinance-sdk-staking: Stakingbinance-sdk-sub-account: Sub Accountbinance-sdk-vip-loan: VIP Loanbinance-sdk-wallet: Walletbinance-sdk-w3w-prediction: W3W PredictionNote: binance-sdk-nft is deprecated.
For detailed API specifications, refer to the Binance API Documentation.
When deciding whether to migrate, note the following structural differences:
| Feature | Monolithic Connector | Modular Connector |
|---|---|---|
| Package Name | binance-connector | binance-sdk-<product> |
| API Coverage | All Binance APIs | Individual APIs (Spot, Wallet, Algo Trading, etc.) |
| Imports | Single package import | Separate package per product |
| Code Structure | One large client | Smaller, focused clients |
Note on Backward Compatibility:
binance-connector.When initializing the ConfigurationRestAPI object, you can specify the number of retries for failed requests using the retries parameter. This configuration is then passed to the SubAccount client to manage automatic retry logic for REST API calls.
from binance_common.configuration import ConfigurationRestAPI
from binance_sdk_sub_account.sub_account import SubAccount
from binance_sdk_sub_account.rest_api.models import GetSummaryOfSubAccountsMarginAccountResponse
configuration = ConfigurationRestAPI(
api_key="your-api-key",
api_secret="your-api-secret",
retries=2
)
client = SubAccount(config_rest_api=configuration)
try:
response = client.rest_api.get_summary_of_sub_accounts_margin_account()
data: GetSummaryOfSubAccountsMarginAccountResponse = response.data()
print(data)
except Exception as e:
print(e)To use the WebSocket API with Key Pair authentication in the binance-sdk-derivatives-trading-coin-futures SDK, you must initialize a ConfigurationWebSocketAPI object with your api_key, private_key, and private_key_passphrase. This configuration is then passed to the DerivativesTradingCoinFutures client via the config_ws_api parameter. Once authenticated, you can establish a connection using client.websocket_api.create_connection() and perform authenticated requests like position_information().
import asyncio
import logging
from binance_common.configuration import ConfigurationWebSocketAPI
from binance_sdk_derivatives_trading_coin_futures.derivatives_trading_coin_futures import DerivativesTradingCoinFutures
from binance_sdk_derivatives_trading_coin_futures.websocket_api.models import PositionInformationResponse
logging.basicConfig(level=logging.INFO)
# Initialize configuration with Key Pair credentials
configuration_ws_api = ConfigurationWebSocketAPI(
api_key="your-api-key",
private_key=private_key,
private_key_passphrase=private_key_passphrase,
)
# Initialize the client with the WebSocket configuration
client = DerivativesTradingCoinFutures(config_ws_api=configuration_ws_api)
async def position_information():
connection = None
try:
# Establish the WebSocket connection
connection = await client.websocket_api.create_connection()
# Perform an authenticated request
response = await client.websocket_api.position_information()
data = response.data()
logging.info(f"position_information() response: {data}")
except Exception as e:
logging.error(f"position_information() error: {e}")
finally:
if connection:
# Close the connection and the session
await connection.close_connection(close_session=True)
if __name__ == "__main__":
asyncio.run(position_information())When initializing the ConfigurationRestAPI object for the Dual Investment SDK, you can enable or disable HTTP compression by setting the compression parameter. Setting compression=True (default behavior depends on implementation, but explicitly set here) allows the client to use compressed responses to reduce bandwidth usage. Set compression=False to disable it.
from binance_common.configuration import ConfigurationRestAPI
from binance_sdk_dual_investment.dual_investment import DualInvestment
configuration = ConfigurationRestAPI(
api_key="your-api-key",
api_secret="your-api-secret",
compression=False
)
client = DualInvestment(config_rest_api=configuration)binance-connector package to a modularized structure. To use Rebate features, you must migrate to the binance-sdk-rebate library. This involves uninstalling the old package, installing the new one, updating import paths, and adjusting how the client is initialized using ConfigurationRestAPI.When using the Fiat client, you can route your REST API requests through a proxy by providing a proxy dictionary to the ConfigurationRestAPI object. The proxy configuration requires a host, port, and protocol ('http' or 'https'). If your proxy requires authentication, include an auth dictionary containing username and password keys.
from binance_common.configuration import ConfigurationRestAPI
from binance_sdk_fiat.fiat import Fiat
configuration = ConfigurationRestAPI(
api_key="your-api-key",
api_secret="your-api-secret",
proxy = {
"host": "127.0.0.1",
"port": 8080,
"protocol": "http", # or 'https'
"auth": {
"username": "proxy-user",
"password": "proxy-password",
},
}
)
client = Fiat(config_rest_api=configuration)The Binance Connector has transitioned from a monolithic binance-connector package to a modularized structure. To use Sub Account features, you must migrate to the binance-sdk-sub-account library.
Uninstall the old package:
pip uninstall binance-connectorInstall the new package:
pip install binance-sdk-sub-accountUpdate Imports:
Replace from binance.spot import Spot as Client with:
from binance_sdk_sub_account.sub_account import SubAccountUpdate Client Initialization:
The new structure requires initializing a ConfigurationRestAPI object first, then passing it to the SubAccount client.
Update Method Calls:
API calls are now accessed through the rest_api attribute of the client instance (e.g., client.rest_api.query_sub_account_list()).
from binance_sdk_sub_account.sub_account import SubAccount, ConfigurationRestAPI
configuration = ConfigurationRestAPI(
api_key="your-key",
api_secret="your-secret"
)
client = SubAccount(config_rest_api=configuration)
response = client.rest_api.query_sub_account_list()When initializing the ConfigurationRestAPI for the DerivativesTradingPortfolioMarginPro client, you can enable or disable response compression using the compression parameter. Setting compression=True enables compressed responses to reduce data transfer size, while compression=False (default) uses uncompressed responses.
from binance_common.configuration import ConfigurationRestAPI
from binance_sdk_derivatives_trading_portfolio_margin_pro.derivatives_trading_portfolio_margin_pro import DerivativesTradingPortfolioMarginPro
from binance_sdk_derivatives_trading_portfolio_margin_pro.rest_api.models import GetPortfolioMarginProAccountInfoResponse
configuration = ConfigurationRestAPI(
api_key="your-api-key",
api_secret="your-api-secret",
compression=False
)
client = DerivativesTradingPortfolioMarginPro(config_rest_api=configuration)
try:
response = client.rest_api.get_portfolio_margin_pro_account_info()
data: GetPortfolioMarginProAccountInfoResponse = response.data()
print(data)
except Exception as e:
print(e)