Client Classes

from ssi_sdk import Auth, Config

config = Config(
    client_id="<CLIENT_ID>",
    api_key="<API_KEY>",
    api_secret="<API_SECRET>",
    private_key="<PRIVATE_KEY_CONTENT>",
)

with Auth(config) as auth:
    # Authenticate with OTP
    token = auth.authenticate(otp="<OTP>")
    print(f"Expires at: {token.expires_at}")

# Request OTP (returns the raw dict)
result = auth.request_otp()

# Same, but returns OTPResponse(message, transaction_id)
otp = auth.request_otp_typed()

# Authenticate with OTP
token = auth.authenticate(otp="<OTP>")

# Refresh token
token = auth.refresh()

# Auto-refresh if expired, or authenticate if needed
access_token = auth.ensure_authenticated(otp="<OTP>")

from ssi_sdk.exceptions import (
    ReauthenticationRequired,
    SmartOTPPendingError,
    SmartOTPRejectedError,
)

# Step 1: send the approval request, get transaction_id
otp = auth.request_otp_typed()

# Step 2: the SDK polls automatically until the user approves in the Smart OTP app
try:
    access_token = auth.ensure_authenticated(
        transaction_id=otp.transaction_id,
        poll_interval_ms=5000,   # milliseconds between polls (default Config.otp_poll_interval_ms = 5000)
        poll_max_retries=12,     # max poll attempts (default derived from Config.otp_poll_max_wait_ms = 60000)
    )
except SmartOTPPendingError:
    # Not approved in time: call again with the same transaction_id
    ...
except SmartOTPRejectedError:
    # Rejected / expired: request a new OTP
    ...
except ReauthenticationRequired:
    # Cannot refresh: authenticate again with a new OTP
    ...

print(auth.token)              # Token object or None
# auth.access_token             # Access token string or None (do not print/log)
print(auth.is_token_expired)   # True/False
print(auth.has_refresh_token)  # True/False

from ssi_sdk import Auth, Data, Config

with Auth(config) as auth:
    auth.authenticate()  # No OTP needed for market data

    with Data(auth) as data:
        # Access via service
        ohlc = data.market_data.get_ohlc_1minute("SSI")
        indices = data.market_data.get_indexes()
        info = data.market_data.get_securities_info("SSI")

from ssi_sdk import Auth, Trading, Config
from ssi_sdk.enums import OrderSide

with Auth(config) as auth:
    auth.authenticate(otp="<OTP>")

    with Trading(auth) as trading:
        # Account
        accounts = trading.account.get_account_info()

        # Portfolio (may return None when the account has no data yet)
        balance = trading.portfolio.get_equity_balance("<EQUITY_ACCOUNT_NO>")
        positions = trading.portfolio.get_equity_positions("<EQUITY_ACCOUNT_NO>")
        orders = trading.portfolio.get_today_orders("<EQUITY_ACCOUNT_NO>")

        # Trading
        result = trading.trading.place_limit_order(
            account_no="<EQUITY_ACCOUNT_NO>",
            symbol="SSI",
            side=OrderSide.BUY,
            quantity=100,
            price=66000,
        )

from ssi_sdk import Auth, Stream, Config

with Auth(config) as auth:
    auth.authenticate(otp="<OTP>")

    with Stream(auth) as stream:
        # Register callbacks BEFORE connect
        stream.streaming.on_data = lambda msg: print(f"Data: {msg}")
        stream.streaming.on_trading = lambda msg: print(f"Trading: {msg}")
        stream.streaming.on_connection = lambda ev: print(f"Conn: {ev.state}")

        stream.streaming.connect()

        # Subscribe
        stream.streaming.subscribe_symbol(["SSI", "HPG"])
        stream.streaming.subscribe_order_status()

        # Wait for data (milliseconds; leave empty to wait until closed)
        stream.streaming.wait(timeout_ms=30_000)

from ssi_sdk import Auth, Config, TradingWSError, trading_ws

with Auth(config) as auth:
    auth.ensure_authenticated(otp="<OTP>")

    try:
        ws = trading_ws(auth)
    except TradingWSError as e:
        raise SystemExit(f"Server rejected the connection: {e}")

    try:
        book = ws.query_order_book("<EQUITY_ACCOUNT_NO>", page_size=10)
        print(book.status)
    finally:
        ws.close()  # always close the socket

import asyncio
from ssi_sdk import AsyncAuth, AsyncData, AsyncTrading, AsyncStream, Config

async def main():
    config = Config(
        client_id="<CLIENT_ID>",
        api_key="<API_KEY>",
        api_secret="<API_SECRET>",
        private_key="<PRIVATE_KEY_CONTENT>",
    )

    async with AsyncAuth(config) as auth:
        await auth.authenticate(otp="<OTP>")

        async with AsyncData(auth) as data:
            ohlc = await data.market_data.get_ohlc_1minute("SSI")
            print(ohlc)

        async with AsyncTrading(auth) as trading:
            accounts = await trading.account.get_account_info()
            print(accounts)

        async with AsyncStream(auth) as stream:
            stream.streaming.on_data = lambda msg: print(msg)
            await stream.streaming.connect()
            await stream.streaming.subscribe_symbol_trade(["SSI"])
            await stream.streaming.wait(timeout_ms=30_000)

asyncio.run(main())