crypto-ws-api 2.0.9

Crypto WS API connector for ASYNC requests

Crypto WS API connector for ASYNC requests

Full coverage of all methods provided by the interface

Provides of connection management, keepalive and rate limits control

---

---

For :heavy_check_mark:Binance, :heavy_check_mark:OKX, :heavy_check_mark:Bitfinex

---

Features

Lightweight and efficient solution to utilize of all available methods** provided through the:

• Binance Websocket API v3
• OKX Websocket API v5
• Bitfinex Websocket Inputs

** Not for channel by one-way subscription, for request <-> response mode only

Session management layer for:

• Credentials
• Connection
• Keepalive
• Error handling
• Limits control
• Methods construction
  • Creating request on-the-fly from method name and params: {}
  • Generating signature if necessary
  • Response handling
• logging

User interface layer

• Start session instance
• Send async request
• Get response or raised exception
• Reuse instance for different type requests
• Stop session instance

Get started

Install use PIP

pip install crypto_ws_api

For upgrade to latest versions use:

pip install -U crypto_ws_api

After first install create environment by run

crypto_ws_api_init

in terminal window.

The config directory will be created. You get path to config:

ubuntu@ubuntu:~$ crypto_ws_api_init

Can't find config file! Creating it...

Before first run set account(s) API key into /home/ubuntu/.config/crypto_ws_api/ws_api.toml

Prepare exchange account

• For test purpose log in at Binance Spot Test Network

For OKX and Bitfinex, unlike Binance, a limited number of methods are implemented at the WS API level, such as creating, modifying, and deleting orders. There are no public get-time (), ping-pong, etc., so this demo script is limited to calling Binance to demonstrate capabilities.

• Create API Key
• After install and create environment specify api_key and api_secret to the config file

Start demo

• Run in terminal window

crypto_ws_api_demo

Useful tips

crypto_ws_api/demo.py - complete and fully functional example

Get credentials and create user session

from crypto_ws_api.ws_session import UserWSSession

# Get credentials and create user session
# Can be omitted if you have credentials from other source
exchange, _test_net, api_key, api_secret, passphrase, ws_api_endpoint = get_credentials(account_name)

session = aiohttp.ClientSession()

trade_id = shortuuid.uuid()

user_session = UserWSSession(
    session,
    exchange,
    ws_api_endpoint,
    api_key,
    api_secret,
    passphrase
)

Method example

async def account_information(user_session: UserWSSession, _trade_id):
    # https://developers.binance.com/docs/binance-trading-api/websocket_api#account-information-user_data
    try:
        res = await user_session.handle_request(
            _trade_id,
            "account.status",
            _api_key=True,
            _signed=True
        )
        if res is None:
            logger.warning("Here handling state Out-of-Service")
    except asyncio.CancelledError:
        pass  # Task cancellation should not be logged as an error
    except Exception as _ex:
        logger.error(f"Handling exception: {_ex}")
    else:
        logger.info(f"Account information (USER_DATA) response: {res}")

Demo method's calling

await account_information(user_session, trade_id)

Stop user session and close aiohttp session

await user_session.stop()
await session.close()

Create limit order example

if self.exchange == 'binance':
    params = {
        "symbol": "BTCUSDT",
        "side": "SELL",
        "type": "LIMIT",
        "timeInForce": "GTC",
        "price": "23416.10000000",
        "quantity": "0.00847000",
    }
    binance_res = await user_session.handle_request(trade_id, "order.place", params, _api_key=True, _signed=True)

elif self.exchange == 'bitfinex':
    params = {
        "type": "EXCHANGE LIMIT",
        "symbol": "tBTCUSDT",
        "price": "23416.10000000",
        "amount": ('' if side == 'BUY' else '-') + "0.00847000",
    }
    bitfnex_res = await user_session.handle_request(trade_id, "on", params)

elif self.exchange == 'okx':
    params = {
        "instId": "BTC-USDT",
        "tdMode": "cash",
        "clOrdId": "client_order_id",
        "side": "buy",
        "ordType": "limit",
        "sz": "0.00847000",
        "px": "23416.10000000",
    }
    okx_res = await user_session.handle_request(trade_id, "order", params)

Logging setup

For configure logging in multi-module project use next snippet for yours main():

import logging.handlers

logger = logging.getLogger(__name__)
formatter = logging.Formatter(fmt="[%(asctime)s: %(levelname)s] %(message)s")
#
sh = logging.StreamHandler()
sh.setFormatter(formatter)
sh.setLevel(logging.DEBUG)
#
root_logger = logging.getLogger()
root_logger.setLevel(logging.DEBUG)
root_logger.addHandler(sh)

Limits control :link:

Upon reaching the limit threshold of each type, the session switches to the Out-of-Service state. If you send a request in this state, the answer will be None

In any case, you are protected from exceeding limits and blocking for this reason

Donate

USDT (TRC20) TU3kagV9kxbjuUmEi6bUym5MTXjeM7Tm8K