Dad Quant

Zerodha Kite Connect Authentication

Nubra Authentication

When you build live trading systems, the first bottleneck isn’t latency — it’s login.
Zerodha’s Kite Connect follows a manual authentication loop that requires opening a browser, logging in, passing two-factor authentication, and finally copying a request token. This token expires every day, meaning your algo needs a human in the loop before markets open.

Nubra, on the other hand, skips the browser entirely. Authentication happens directly inside your code using an SDK command like:

from nubra_python_sdk.start_sdk import InitNubraSdk, NubraEnv

# Initialize the Nubra SDK client
nubra = InitNubraSdk(NubraEnv.PROD)

For developers running algos on VPS or servers, Nubra also supports TOTP-based login — meaning you can generate a time-based authentication code once, store credentials in a .env file, and run fully automated logins without any human input.

Zerodha’s WebSocket streams raw exchange-level tick data — exactly as received from the exchange.
This data needs preprocessing, symbol mapping, and cleanup before it can be used in a trading model.
Developers must then write separate code modules to calculate analytics like Implied Volatility (IV), Delta, Theta, and Vega, making the overall workflow slower and more complex.

Nubra, on the other hand, delivers tick-level data enriched with analytics.
Its WebSocket stream includes live option Greeks, order book details, and market depth for every instrument — all in structured, ready-to-use Python objects.
This removes the need for additional preprocessing or analytical computation, letting developers focus entirely on strategy logic and execution.

Zerodha Tick Stream Example:

{
  'tradable': True,
  'instrument_token': 12212994,
  'last_price': 398.65,
  'volume_traded': 7404225,
  'ohlc': {'open': 288.05, 'high': 419.7, 'low': 230.15, 'close': 302.95},
  'oi': 1303275,
  'depth': {
      'buy': [{'quantity': 375, 'price': 397.25}, ...],
      'sell': [{'quantity': 300, 'price': 398.05}, ...]
  }
}

Nubra (Options Greeks) Stream Example:

OptionData(
  ref_id=942993,
  strike_price=2350000,
  lot_size=75,
  last_traded_price=242935,
  delta=0.9967,
  gamma=4.97e-05,
  theta=-0.7176,
  vega=0.2772,
  open_interest=0,
  volume=1275
)

A delta-neutral short strangle involves selling one out-of-the-money call and one out-of-the-money put such that the combined delta of both legs ≈ 0.

This strategy profits from time decay (positive Theta) and benefits when implied volatility (IV) drops. While the concept is simple, implementation complexity varies dramatically depending on the platform you use.

Let’s see how the same strategy looks when built on Zerodha’s Kite Connect vs Nubra’s SDK.

Strategy Deployment on Zerodha

Strategy Deployment on Nubra

Zerodha (Kite Connect): Manual Multi-Leg Execution

• Operates at a per-leg level — each option leg (Call, Put, Stop-Loss) requires a separate REST API call.
• Tick data from WebSocket arrives raw and unstructured, requiring preprocessing and cleaning before analytics.
• Greeks and implied volatility must be calculated manually using external code or libraries.
• Strike selection for a strategy like a short strangle depends on these custom-computed Greeks.
• Execution is sequential — each order (sell, stop-loss, target) is placed and confirmed independently.
• Requires constant monitoring of each leg’s PnL and delta exposure.
• Exit logic such as OCO (One Cancels Other) or combined target/stop-loss handling must be manually coded.

Nubra (Flexi Basket SDK): Unified Multi-Leg Execution

• Treats the entire strategy as one basket, not individual legs.
• Uses a single Flexi Basket Order to execute multiple legs (e.g., call and put) in one atomic transaction.
• All parameters — entry price, stop-loss, and target — are defined at the basket level, not per order.
• Built-in OCO logic and risk management automatically handle exits and cancellations.
• Streams real-time analytics (Greeks, IV, deltas) directly via the SDK — no preprocessing needed.
• All legs update in real time within the basket; PnL and risk are tracked collectively.
• Reduces API load and latency by eliminating redundant API calls.

This modular setup offers flexibility but adds latency — more computation blocks, multiple API hits, and continuous supervision — slowing down live strategy responsiveness.

This architecture minimizes latency, eliminates redundant monitoring loops, and lets traders focus on strategy design rather than execution plumbing.