pip install bittrex-websocket

pip install git+https://github.com/slazarov/python-bittrex-websocket.git

pip install git+https://github.com/slazarov/python-bittrex-websocket.git@next-version-number

def subscribe_to_orderbook(self, tickers, book_depth=10):
    """
    Subscribe and maintain the live order book for a set of ticker(s).

    :param tickers: A list of tickers you are interested in.
    :type tickers: []
    :param book_depth: The desired depth of the order book to be maintained.
    :type book_depth: int
    """

def subscribe_to_orderbook_update(self, tickers):
    """
    Subscribe to order book updates for a set of ticker(s).

    :param tickers: A list of tickers you are interested in.
    :type tickers: []
    """

def subscribe_to_trades(self, tickers):
    """
    Subscribe and receive tick data(executed trades) for a set of ticker(s).

    :param tickers: A list of tickers you are interested in.
    :type tickers: []
    """

def subscribe_to_ticker_update(self, tickers):
    """
    Subscribe and receive general data updates for a set of ticker(s). Example output:

    {
        'MarketName': 'BTC-ADA',
        'High': 7.65e-06,
        'Low': 4.78e-06,
        'Volume': 1352355429.5288217,
        'Last': 7.2e-06,
        'BaseVolume': 7937.59243908,
        'TimeStamp': '2017-11-28T15:02:17.7',
        'Bid': 7.2e-06,
        'Ask': 7.21e-06,
        'OpenBuyOrders': 4452,
        'OpenSellOrders': 3275,
        'PrevDay': 5.02e-06,
        'Created': '2017-09-29T07:01:58.873'
    }

    :param tickers: A list of tickers you are interested in.
    :type tickers: []
    """

def unsubscribe_from_orderbook(self, tickers):
    """
    Unsubscribe from real time order for specific set of ticker(s).

    :param tickers: A list of tickers you are interested in.
    :type tickers: []
    """

def unsubscribe_from_orderbook_update(self, tickers):
    """
    Unsubscribe from order book updates for a set of ticker(s).

    :param tickers: A list of tickers you are interested in.
    :type tickers: []
    """

def unsubscribe_from_trades(self, tickers):
    """
    Unsubscribe from receiving tick data(executed trades) for a set of ticker(s)

    :param tickers: A list of tickers you are interested in.
    :type tickers: []
    """

def unsubscribe_from_ticker_update(self, tickers):
    """
    Unsubscribe from receiving general data updates for a set of ticker(s).

    :param tickers: A list of tickers you are interested in.
    :type tickers: []
    """

def get_order_book(self, ticker=None):
    """
    Returns the most recently updated order book for the specific ticker.
    If no ticker is specified, returns a dictionary with the order books of
    all subscribed tickers.

    :param ticker: The specific ticker you want the order book for.
    :type ticker: str
    """

def get_order_book_sync_state(self, tickers=None):
    """
    Returns the sync state of the order book for the specific ticker(s).
    If no ticker is specified, returns the state for all tickers.
    The sync states are:

        Not initiated = 0
        Invoked, not synced = 1
        Received, not synced, not processing = 2
        Received, synced, processing = 3

    :param tickers: The specific ticker(s) and it's order book sync state you are interested in.
    :type tickers: []
    """

def disconnect(self):
    """
    Disconnects the connections and stops the websocket instance.
    """

def enable_log(file_name=None):
    """
    Enables logging.

    :param file_name: The name of the log file, located in the same directory as the executing script.
    :type file_name: str
    """

def disable_log():
    """
    Disables logging.
    """

def on_open(self):
    # Called before initiating the first websocket connection
    # Use it when you want to add some opening logic.

def on_close(self):
    # Called before closing the websocket instance.
    # Use it when you want to add any closing logic.

def on_error(self, error):
    # Error handler

def on_orderbook(self, msg):
    # The main channel of subscribe_to_orderbook().

def on_orderbook_update(self, msg):
    # The main channel of subscribe_to_orderbook_update().

def on_trades(self, msg):
    # The main channel of subscribe_to_trades().

def on_ticker_update(self, msg):
    # The main channel of subscribe_to_ticker_update().

# Tickers
tickers = ['ETH-ZEC'] # use lists
ws = MySocket()
ws.subscribe_to_orderbook(tickers)
# Do some stuff and trade for infinite profit
ws.disconnect()

# Tickers
tickers = ['BTC-ETH', 'BTC-NEO', 'BTC-ZEC', 'ETH-NEO', 'ETH-ZEC'] # use lists
ws = MySocket()
ws.subscribe_to_ticker_update(tickers)
# Do some stuff and trade for infinite profit
ws.disconnect()

from __future__ import print_function
from time import sleep
from bittrex_websocket.websocket_client import BittrexSocket


def main():
    class MySocket(BittrexSocket):
        def on_open(self):
            self.trade_history = {}

        def on_trades(self, msg):
            # Create entry for the ticker in the trade_history dict
            if msg['ticker'] not in self.trade_history:
                self.trade_history[msg['ticker']] = []
            # Add history nounce
            self.trade_history[msg['ticker']].append(msg)
            # Ping
            print('[Trades]: {}'.format(msg['ticker']))

    # Create the socket instance
    ws = MySocket()
    # Enable logging
    ws.enable_log()
    # Define tickers
    tickers = ['BTC-ETH', 'BTC-XMR']
    # Subscribe to trade fills
    ws.subscribe_to_trades(tickers)

    while len(set(tickers) - set(ws.trade_history)) > 0:
        sleep(1)
    else:
        for ticker in ws.trade_history.keys():
            print('Printing {} trade history.'.format(ticker))
            for trade in ws.trade_history[ticker]:
                print(trade)
        ws.disconnect()

if __name__ == "__main__":
    main()

from __future__ import print_function
from time import sleep
from bittrex_websocket.websocket_client import BittrexSocket


def main():
    class MySocket(BittrexSocket):
        def on_orderbook(self, msg):
            print('[OrderBook]: {}'.format(msg['MarketName']))

    # Create the socket instance
    ws = MySocket()
    # Enable logging
    ws.enable_log()
    # Define tickers
    tickers = ['BTC-ETH', 'BTC-NEO', 'BTC-ZEC', 'ETH-NEO', 'ETH-ZEC']
    # Subscribe to live order book
    ws.subscribe_to_orderbook(tickers)

    while True:
        i = 0
        sync_states = ws.get_order_book_sync_state()
        for state in sync_states.values():
            if state == 3:
                i += 1
        if i == len(tickers):
            print('We are fully synced. Hooray!')
            for ticker in tickers:
                ob = ws.get_order_book(ticker)
                name = ob['MarketName']
                quantity = str(ob['Buys'][0]['Quantity'])
                price = str(ob['Buys'][0]['Rate'])
                print('Ticker: ' + name + ', Bids depth 0: ' + quantity + '@' + price)
            ws.disconnect()
            break
        else:
            sleep(1)

if __name__ == "__main__":
    main()

from __future__ import print_function
from time import sleep
from bittrex_websocket.websocket_client import BittrexSocket


def main():
    class MySocket(BittrexSocket):
        def on_open(self):
            self.ticker_updates_container = {}

        def on_ticker_update(self, msg):
            name = msg['MarketName']
            if name not in self.ticker_updates_container:
                self.ticker_updates_container[name] = msg
                print('Just received ticker update for {}.'.format(name))

    # Create the socket instance
    ws = MySocket()
    # Enable logging
    ws.enable_log()
    # Define tickers
    tickers = ['BTC-ETH', 'BTC-NEO', 'BTC-ZEC', 'ETH-NEO', 'ETH-ZEC']
    # Subscribe to ticker information
    ws.subscribe_to_ticker_update(tickers)

    while len(ws.ticker_updates_container) < len(tickers):
        sleep(1)
    else:
        print('We have received updates for all tickers. Closing...')
        ws.disconnect()

if __name__ == "__main__":
    main()