Python SDK

Live streams

SahiFeed: the tick stream and order updates, with reconnect and a local tick cache.

SahiFeed connects to the tick stream and the order-update stream.

Callbacks run on the thread that calls consume(), one at a time. If ticks queue up, only the newest per instrument is delivered; order updates all arrive in order.
Ticks have every field, shaped as the REST endpoints return them: an unset field is None, an empty side of the book [], an unset count 0.
Reconnects are automatic after a drop, and subscriptions are re-sent.
Close codes 4401, 4403 and 4429 are final: consume() raises. After a new token, build a new feed.
Logging goes to the sahiapi.sahi.feed and sahiapi.sahi.ws_client loggers.

Examples use api and instrument_id from Getting started, and feed from below.

Build a feed#

class SahiFeed(...)

SahiFeed(api: SahiAPI)

Takes a SahiAPI and copies its token. Nothing connects until the first subscribe.

method feed.subscribe_ltp(...)

feed.subscribe_ltp(instrument_ids: list[int], on_data_received: Callable[[dict, dict], None] | None = None) -> None

Subscribes instruments at LTP mode. If any id is refused, the whole batch is refused and your callback gets an error event.

instrument_ids list[int] Required

Up to 1000 per connection.

on_data_received callable Optional

callback(data, meta). meta["type"] is ltp_tick, quote_tick, depth_tick, ack or error. One callback serves all three modes.

Example python

def on_tick(data, meta):
    if meta["type"] == "ltp_tick":
        print(data["instrument_id"], data["last_trade_price"] / 100)

feed.subscribe_ltp([instrument_id], on_data_received=on_tick)
feed.consume()  # blocks; stop with Ctrl+C

method feed.subscribe_quote(...)

feed.subscribe_quote(instrument_ids: list[int], on_data_received: Callable[[dict, dict], None] | None = None) -> None

As subscribe_ltp, at QUOTE mode: adds volume_today, the price band and open interest.

method feed.subscribe_depth(...)

feed.subscribe_depth(instrument_ids: list[int], on_data_received: Callable[[dict, dict], None] | None = None) -> None

As subscribe_ltp, at DEPTH mode: adds best_buys and best_sells.

Change mode#

method feed.change_mode(...)

feed.change_mode(instrument_ids: list[int], mode: str) -> None

Moves instruments to another mode.

instrument_ids list[int] Required

Ids to move.

mode str Required

SahiAPI.MODE_LTP, MODE_QUOTE or MODE_DEPTH.

Raises#

ValueError: unknown mode.

Unsubscribe#

method feed.unsubscribe(...)

feed.unsubscribe(instrument_ids: list[int]) -> None

Stops ticks for these instruments and clears their cached values.

Latest cached tick#

method feed.last_ltp(...)

feed.last_ltp(instrument_id: int) -> dict | None

The newest LTP tick held for an instrument, or None until one arrives. The cache fills even without consume(), so you can poll it.

Raises#

SahiFeedNotSubscribedException: not subscribed.
The SahiFeedException that closed the stream, once it has.

Latest cached quote#

method feed.last_quote(...)

feed.last_quote(instrument_id: int) -> dict | None

As feed.last_ltp, for QUOTE ticks.

Latest cached depth#

method feed.last_depth(...)

feed.last_depth(instrument_id: int) -> dict | None

As feed.last_ltp, for DEPTH ticks.

Order updates#

method feed.subscribe_order_updates(...)

feed.subscribe_order_updates(on_data_received: Callable[[dict, dict], None], *, on_connect: Callable[[], None] | None = None) -> None

Streams every order event on the account. Updates can repeat and are not replayed after a gap, so take a snapshot with get_order_list() in on_connect and keep the newer last_modified_at per order: see Stream + Snapshot.

on_data_received callable Required

callback(order, meta), one order object per update.

on_connect callable Optional

Called after every connect and reconnect.

Example python

orders = {}

def merge(o):
    seen = orders.get(o["order_id"])
    if seen is None or o["last_modified_at"] >= seen["last_modified_at"]:
        orders[o["order_id"]] = o

def snapshot():
    for o in api.get_order_list()["orders"]:
        merge(o)

feed.subscribe_order_updates(lambda o, meta: merge(o), on_connect=snapshot)
feed.consume()

Run the callbacks#

method feed.consume(...)

feed.consume() -> None

Blocks and runs your callbacks until stop() is called. However it ends, both streams are stopped.

Raises#

SahiFeedAuthExpiredException: the token expired (4401).
SahiFeedForbiddenException: the token lacks the scope (4403).
SahiFeedConnectionException: too many connections (4429).
Anything your callback raised.

Stop both streams#

method feed.stop(...)

feed.stop() -> None

Closes both connections and unblocks consume(). Safe from any thread.

Live streams

Build a feed#

Subscribe for last price#

Subscribe for quotes#

Subscribe for depth#

Change mode#

Raises#

Unsubscribe#

Latest cached tick#

Raises#

Latest cached quote#

Latest cached depth#

Order updates#

Run the callbacks#

Raises#

Stop both streams#