All notable changes to this project will be documented in this file.
The format is based on Keep a Changelog, and this project adheres to Semantic Versioning.
- Demo Trading support
- Add methods for the Institutional Loan endpoints
- Add Account methods
repay_liability()
,set_collateral_coin()
,batch_set_collateral_coin()
tld
arg for users in The Netherlands and Hong Kong forHTTP
sessions
- Options WebSocket failing to maintain connection (bybit-exchange#164)
- Improved the IP rate limit error message to indicate that an HTTP status code 403 may also mean that the IP address was identified as being from the USA – all requests from USA IPs are banned by Bybit.
- Add RSA authentication for HTTP and WebSocket (choose "Self-generated API Keys" when creating an API key)
- Add the
HTTP
methodget_server_time()
- Add
HTTP
methods for spot margin trading - Add
HTTP
methodget_long_short_ratio()
- Add optional
private_auth_expire
arg for WebSocket (bybit-exchange#154)
- The
HTTP
methodenable_universal_transfer_for_sub_uid()
- Improve
close_position
logic
helpers.py
which includes theHelpers
class and theclose_position
method, which can be imported and employed like so:
from pybit.helpers import Helpers
my_helper = Helpers(session) # your HTTP session object (eg, from pybit.unified_trading import HTTP)
print(my_helper.close_position(category="linear", symbol="BTCUSDT"))
- The following new endpoints to
unified_trading
:get_broker_earnings
get_announcement
get_pre_upgrade_order_history
get_pre_upgrade_trade_history
get_pre_upgrade_closed_pnl
get_pre_upgrade_transaction_log
get_pre_upgrade_option_delivery_record
get_pre_upgrade_usdc_session_settlement
get_affiliate_user_info
get_uid_wallet_type
- Multiple symbol support for WebSocket topics (pass
symbol
as a list) - Extra logging (log response headers) when passing
log_requests=True
- Argument
return_response_headers
forHTTP
to allow returning the response headers to the user
- Add response headers to exceptions
- Update PyPI package's python version so that only =>3.9 is supported to prevent the error:
TypeError: 'type' object is not subscriptable
- Fix API rate limit handling
- Remove unnecessary
print
statements in two methods
- New asset endpoints:
set_deposit_account()
,get_internal_deposit_records()
,get_withdrawable_amount()
- Ensure that
legacy
submodule is packaged bysetup.py
- Fix non-UTA (normal account) spot margin trading endpoints
- Fix wrong request method for
set_dcp()
- HTTP endpoints to the
copy_trading
module
- Docstrings in the
copy_trading
module to make it easier to find the API documentation for reference - Example files
ticker_stream
method in theunified_trading
module, which was subscribing to the wrong WebSocket topic
This version upgrades pybit to Bybit's version 5 (v5) APIs. It supports both Unified Trading Accounts (UTA) and non-UTA accounts. Bybit is not expected to develop any more major API versions in the future, so Bybit's v5 API (and subsequently, pybit's 5.0.0) is expected to be supported in the long-term.
See the examples folder for examples on how to interact with the latest modules.
- Bybit's v5 HTTP and WebSocket APIs in the
unified_trading
module. See what markets All-In-One V5 API supports in the upgrade guide.
- Non-v5 modules like
copy_trading
,usdc_options
, andusdc_perpetuals
to continue to work from alegacy
subpackage. Import like so:from pybit.legacy.copy_trading import HTTP
. These modules are maintained because they are currently not supported by the v5 API; see the upgrade guide.
- Various legacy modules which have been superseded by the v5 API via the
unified_trading
module
- Tests for V5 endpoints
copy_trading
module for the Copy Trading HTTP API and WebSocket
requirements.txt
to require the latest version ofwebsocket-client
:1.5.0
.- If you are facing any problems with the WebSocket, ensure you upgrade to the right version of the dependency and try again. Upgrade like so:
python -m pip install -r requirements.txt
- If you are facing any problems with the WebSocket, ensure you upgrade to the right version of the dependency and try again. Upgrade like so:
- WebSocket pings (again)
- How WebSocket pings are sent in an effort to keep connections open longer
- Failure to resubscribe to private spot topics when reconnecting WebSocket
- WebSocket error handling
- Failure to pass request parameters in certain methods
- Wrong endpoint paths in
spot
- Refactored WebSocket's
test
arg totestnet
- Hardcoded WebSocket arguments into the child class the user accesses – meaning the user can easily see them, and IDEs should autocomplete them
- (For v3 WebSockets only:
contract
,unified_margin
,spot
)
- (For v3 WebSockets only:
This version upgrades pybit to Bybit's version 3 (v3) APIs. Some old API modules are maintained due to lack of or only partial support in v3. Method names have been improved and conform to an intuitive standard.
Future modules will be removed as Bybit's APIs are further unified so that they may be accessible from just one or two modules which should generally be divided by account type (eg, unified margin) rather than by market type (eg USDT perpetual).
This is a pre-release, as indicated by the rc
(release candidate) in the version number. Future versions may have breaking changes. An imminent major version of the Bybit API will introduce major changes before these v3 APIs make it to the production version.
- Bybit's main v3 HTTP and WebSocket APIs:
contract
– inverse perpetuals, inverse futures, USDT perpetuals, and USDC optionsunified_margin
– USDT perpetuals and USDC options
spot
to use v3 HTTP API and WebSocket APIsaccount_asset
to use v3 HTTP API
usdt_perpetual
because it is now accessible viacontract
andunified_margin
is_connected()
and the WebSocket reconnection logic.
- See below release candidates for further changes.
- Wrong endpoint path in
usdc_perpetual.py
- Wrong endpoint path in
account_asset.py
- USDC API's timestamp parameter
- The way in which the WebSocket handles errors, improving general usage and debugging (tracebacks) as well as clearly defining under which errors should the WebSocket attempt reconnection.
- USDC API's timestamp parameter to avoid the occasional ret_msg: error sign!
HTTP
methods for account asset's universal transfer API
- USDC API to use the user's set
recv_window
- Did some internal code reorganisation
- The
ping_interval
to 20 seconds to ensure WebSocket connection stability
HTTP
methods for the spot API's Leveraged Token and Cross Margin endpointsagentSource
parameter when sending requests to place spot orders, which uses thereferral_id
argument, so that affiliates can track orders
- There was a packaging problem with the previous version. There are no changes compared with 2.2.2.
- See below release candidates for further changes. TLDR: Improved WebSocket stability and reconnection logic.
retries
argument so that users specify how many times the WebSocket tries to reconnect upon disconnection- The default is
10
. To retry forever, set it to0
. pybit will wait 1 second between each retry.
- The default is
- Improved the logging around WebSocket disconnection
- WebSocket topic resubscription so that when a WebSocket connection is dropped and then reconnected it should resume pushing the same data as before. Essentially, completes the expected functionality of reconnecting to the WebSocket.
is_connected()
function to work with modules that utilise >1 WebSocket connections
is_connected()
function toWebSocket
class so that you can check if your WebSocket connection is alive
- Bug where, upon WebSocket disconnection, pybit rapidly tries to re-establish the connection, which results in being banned by the CDN for malicious activity
- Improved HTTP error handling and logging to ease troubleshooting
usdt_perpetual
->get_risk_limit()
to not require authentication
usdt_perpetual
->add_reduce_margin()
to use the correct request method
- USDC options
WebSocket
andHTTP
classes - Deposit/withdrawal endpoints to
account_asset
module
- Initiating a WebSocket object without an
api_key
orapi_secret
for objects that create multiple WebSocket connections - Error thrown when processing WebSocket orderbook
- USDC perpetual
WebSocket
andHTTP
classes - USDT perpetual
extended_user_trade_records()
method
- Expose all WebSocket arguments to users (fixing the previous "wonky and unintuitive" implementation by simplifying the inheritance design)
- See below release candidates for details.
- Added arg (
trace_logging
) to enable websocket-client's trace logging, which reveals extra debug information regarding the websocket connection, including the raw sent & received messages- Note: the code implementation is a little wonky and unintuitive, and will be refined as much as possible before the proper release - although the functionality will remain the same.
- The processing of
instrument_info
WebSocket messages so that the user receive a"type": "snapshot"
every time, rather than having to do their own delta/snapshot processing - Fix
AttributeError: '_FuturesWebSocketManager' object has no attribute 'endpoint'
when attempting reconnect
record_request_time
arg toHTTP
classes which, if true, returns the response dictionary in a tuple with the request elapsed time - as recorded byrequests
websocket_example.py
to demonstrate callbacks clearly- the license to reflect the transition to bybit-exchange
JSONDecodeError
when trying to subscribe to a spot private WebSocket stream
- New modules for each API as part of a restructuring effort:
inverse_perpetual.py
,usdt_perpetual.py
,spot.py
, and more- see the README for how to import these new modules
HTTP
andWebSocket
classes within each applicable module- These classes use inheritance to reflect the structure of the Bybit APIs - due to the division of endpoints along the lines of different market types
- This means that different classes can share their common endpoints, such as
api_key_info()
, whilst keeping their distinctive endpoints likeget_active_order()
separate
WebSocket
functionality to use callbacks instead of polling- This means that instead of polling
ws.fetch()
for your latest WebSocket messages, you can now simply define a function (my_callback_function
), and pass this as an argument upon subscribing to your chosen topic- see the example file for more information
- This also removes the need to remember topic names and JSON formats, as you now directly call a class method to subscribe
- There is also a
custom_topic_stream
method which can be used if a new WebSocket topic has been released by Bybit, but it's not been added topybit
yet
- This means that instead of polling
HTTP
classes will now instantiate a new HTTP session for each API (Spot (spot.HTTP
), Account Asset (account_asset.HTTP
), etc)- this is due to the restructuring of
pybit
to use class inheritance
- this is due to the restructuring of
- Generally, the restructuring has allowed a great amount of segregation of the internal code to occur, which will allow for easier future development
- The
WebSocket
class from the__init__.py
file, which was imported like so:from pybit import WebSocket
- This is because of the aforementioned functionality changes, which also have the potential to improve performance (as a core no longer needs to be occupied polling
ws.fetch()
)
- This is because of the aforementioned functionality changes, which also have the potential to improve performance (as a core no longer needs to be occupied polling
- However, the
HTTP
class was not removed from__init__.py
in an effort to provide a unified alternative- Despite this, we would recommend preferring the market-specific modules
- Added
query_trading_fee_rate()
position_mode_switch()
to support USDT perp:/private/linear/position/switch-mode
endpoint
arg toget_active_order()
- A WebSocket test case, by raising an exception instead of logging
- Improve
get_risk_limit()
- Fixed: call this endpoint without authentication
- Supported
endpoint
argument formy_position()
, allowing the user to call this method without supplying a symbolsymbol
is not a required parameter for these endpoints, but pybit typically relies on it for deciding which endpoint to call
- Enabled WebSocket
fetch()
to handle multiple position sides from linear perp symbols - Fixed
fetch()
for private spot WebSocket - Supported
endpoint
argument formy_position()
, allowing the user to call this method without supplying a symbolsymbol
is not a required parameter for these endpoints, but pybit typically relies on it for deciding which endpoint to call
- See below release candidates for details.
- Alter the spot endpoint paths used for
get_active_order()
andquery_active_order()
- Fixed failure to load subscriptions when provided in as JSON strings
- Fixed the spot auth WebSocket to ensure subscriptions are not required
- Fixed methods like
query_symbol()
(which have no API parameters) not working following the spot update
- Implemented the Spot API in
HTTP
- Implemented the Account Asset API in
HTTP
- Implemented the Spot WebSocket in
WebSocket
- Removed
position_mode_switch()
as the endpoint has not been released to mainnet yet
- Added new
HTTP
methods for new endpoints - Added new paths for existing methods
- Fixed some old paths
is_linear
argument inget_risk_limit()
- Added some logic to decide if there is 'order_book' in order book snapshot push for WebSocket
- Added
ignore_codes
argument toHTTP
for status codes to not raise any errors on.
- Removed extra suffix definition block in
place_conditional_order
. - Changed logger functionality so that it won't overwrite user's preferred logging settings.
- Fixed wrong number of arguments error inside WebSocket
on_message
,on_close
,on_open
,on_error
.
- Fixed typo errors on endpoint urls.
- Added support for futures endpoints on
HTTP
(usingisdigit
to detect futures symbols).
- Using
get
method fordict
for symbol check instead of calling by key. endpoint
onHTTP
will now default to https://api.bybit.com if no argument.retry_codes
is now user-definable in theHTTP
arguments.- All logging is now on
DEBUG
level—user will need to manually setlogging_level
toDEBUG
. - Added attempted request to
FailedRequestError
andInvalidRequestError
for improved error logging.
- Fixed unexpected
tuple
generation for status codes onInvalidRequestError
andFailedRequestError
. - Fixed how
Websocket
handles incomingorderBook
data due to Bybit's topic naming changes.
requests
will useJSONDecodeError
fromsimplejson
if it is available—pybit
will now do the same to prevent errors.- Fixed a bug where
HTTP
retry would crash on rate limit reached due to undefined variable. - Improved
InvalidRequestError
andFailedRequestError
to include error codes and times.
WebSocket
will now temporarily differentiate between inverse and linear endpoints for the 'order' topic since incoming data has differing keys.
WebSocket
now haspurge_on_fetch
(defaults toTrue
), which allows the user to keep data between fetches.
- Fixed a bug on 'stop_order' for
WebSocket
that would prevent data from being appended due to deprecation ofstop_order_id
.
- See release candidates for details.
- Rewrote if-condition on
_on_message
inWebSocket
class to check for linear or non-linear position data.
- Added ability to handle
from
usingfrom_time
andfrom_id
arguments sincefrom
is a reserved keyword. - Removed
ignore_retries_for
fromHTTP
.pybit
now uses a standard list of non-critical errors that can be retried. - Added argument
retry_delay
forHTTP
—allows user to add a custom retry delay for each retry.
- See release candidates for details.
- Fixed raise error missing argument for
FailedRequestError
upon max retries. - Modified API endpoints to saistfy requirements for upcoming endpoint deprecation, see the API Documentation for more info.
- Updated
WebSocket
class to properly handlecandle
from USDT perpetual streams. - Updated
WebSocket
class to return a copy of the collected data, preventing establishing a reference. - Updated
WebSocket
class to properly handle linear (USDT) orderbook data. - Performance improvements.
- Changed
ignore_retries_for
default argument to be empty tuple to prevent error.
- Added
ignore_retries_for
argument toHTTP
auth
method, allowing the user to choose which error codes should NOT be retried.
FailedRequestError
andInvalidRequestError
now havemessage
andstatus_code
attributes.
- Will now catch and handle
requests.exceptions.ConnectionError
.
- Added
recv_window
error handler toHTTP
auth
method. - Will now catch and handle
requests.exceptions.SSLError
.
- Added
recv_window
argument toHTTP
class.
- Improved error handling.
- Added
max_retries
argument toHTTP
class.
- Added
FailedRequestError
to differentiate between failed requests and invalid requests. - Fixed
exit
method onWebSocket
to now properly handle the closing of the socket.
- Increased expires time for WebSocket authentication to a full second.
- Add option to handle timeout on request submission.
- Fixed trailing decimal zero to prevent auth signature errors.
- New
HTTP
methods. - New argument for
HTTP
class to log each outgoing request. - New argument for
WebSocket
class to attempt restart after an error is detected.
- Mass simplification of all methods—each method now takes a series keyword arguments rather than a set number of required pre-defined arguments. This makes the library future-proof and prevents breaking on significant updates to the REST API endpoints. This, however, requires the user to study the API documentation and know which arguments are required for each endpoint.
- One new exception has been added—
InvalidRequestError
. This exception will be raised if Bybit returns with an error, or ifrequests
is unable to complete the request. - Inverse and Linear endpoints are now handled accordingly by differentiating from the symbol argument.
- Updated existing
HTTP
method names to follow the same naming procedure as listed in the Bybit API documentation. - Reformatting of code to follow PEP-8 standards.
- New docstring format.
- Various logging features added to both HTTP and WebSocket classes.
- Extensive WebSocket class updates.
- Modified the WebSocketApp to send a heartbeat packet every 30 seconds, with a timeout of 10 seconds. These settings can be modified using the 'ping_interval' and 'ping_timeout' arguments of the WebSocket constructor.
- User no longer needs to manage the incoming stream;
pybit
does all the work (insert, update, delete). - Modified
ws.ping()
for ease of use; simply use the function to send heartbeat packets. When something happens to the connection, Python will raise anException
which the end-user can catch and handle.
- Redundancy updates to the HTTP class.
- Modified the HTTP class to use an endpoint argument, allowing users to take advantage of the USDT endpoints.
- The setup.py file has been fixed to correctly install the pybit package.
- The
pybit
module. - MANIFEST, README, LICENSE, and CHANGELOG files.