Chart Data

symbolInfo

The symbol being charted (option, future, equity, or index).

String get symbolInfo => jsonEncode({
  'id': 'RELIANCE',
  'name': 'Reliance Industries',
  'lotSize': 1,
  'precision': 2,
  'tickSize': 0.05,
  'exchange': 'NSE',
  'expiry': '', // e.g. '2025-03-27' for a derivative; empty for this equity
  'strike': '', // e.g. '23000' for an option; empty for this equity
  'optType': '', // e.g. 'CE' or 'PE' for an option; empty for this equity
  'weekly': '', // e.g. 'Y' marks a weekly expiry; empty for this equity
  'undID': '', // e.g. 'NIFTY' for a derivative; empty for this equity
  'description': '', // e.g. 'Reliance Industries Limited'
  'trdUnit': '', // e.g. 'EQ'
});

underlyingSymbolInfo (same shape, String?) is the underlying when symbolInfo is itself a derivative; return "" (empty) when symbolInfo is already the underlying (equity or index). null is also accepted — see the callout below — but there's no reason to reach for it.

underlyingSymbolInfoFor

The parameterized replacement for underlyingSymbolInfo above — resolves the underlying for an explicit symbolId instead of "whatever's currently charted." Called every time the SDK needs a symbol's underlying, starting with the very first chart load, so implement it before shipping against this SDK version — there's no partial-integration path for this one.

Future<String?> underlyingSymbolInfoFor(String symbolId);

Same shape as symbolInfo, same null convention as underlyingSymbolInfo above — null when symbolId is itself the underlying (equity or index).

Symbol lists

optionSymbols, futureSymbols, and indexSymbols — resolved once at startup, alongside symbolInfo and marketTimings.

String get optionSymbols => '[]'; // see shape below
String? get futureSymbols => null;
String? get indexSymbols => null;

Each resolves to a JSON array of symbol objects, same shape as symbolInfo:

[
  { "id": "NIFTY25MAR23000CE", "name": "NIFTY 23000 CE Mar 27", "strike": "23000", "expiry": "2025-03-27", "optType": "CE", "lotSize": 50, "precision": 2, "tickSize": 0.05, "exchange": "NSE", "undID": "NIFTY" }
]

optionSymbolsFor / futureSymbolsFor

The parameterized replacements for optionSymbols/futureSymbols above — scoped to an explicit underlyingId instead of relying on client-side filtering by undID.

Future<String> optionSymbolsFor(String underlyingId); // non-nullable, "[]" when empty
Future<String?> futureSymbolsFor(String underlyingId);

Same shape as optionSymbols/futureSymbols above. Unlike the ambient members, you are responsible for scoping the result to underlyingId yourself — on every platform, not just web, there is no filtering step left downstream of this call. Return "[]" (options) or null/"[]" (futures) when nothing matches underlyingId.

marketTimings

Exchange calendars, as a JSON map keyed by exchange code. This is a map (not a single calendar) because a derivative and its underlying can trade on different exchanges with different session hours — e.g. NSE and NFO, after SEBI's Call Auction Session diverged their timing. Look up a specific exchange's calendar with marketTimingFor(exchange).

String get marketTimings => jsonEncode({
  'NSE': {
    'timezone': 'Asia/Kolkata',
    'sessions': [
      ['0915-1530'], ['0915-1530'], ['0915-1530'], ['0915-1530'], ['0915-1530'], [], [],
    ],
    'holidays': ['20260126'],
    'special': { '20260201': ['0915-1530'] },
  },
  'NFO': {
    'timezone': 'Asia/Kolkata',
    'sessions': [
      ['0900-1530'], ['0900-1530'], ['0900-1530'], ['0900-1530'], ['0900-1530'], [], [],
    ],
    'holidays': ['20260126'],
    'special': { '20260201': ['0900-1530'] },
  },
});

loadData

Called for historical OHLCV bars — initial load, on scroll (older bars), and on timeframe change.

Future<String> loadData({
  required String symbolId,
  required int from,
  required int to,
  required int intervalSeconds,
  required int requiredBars,
});

Returns a JSON-encoded array of arrays, oldest first, each bar [time, open, high, low, close, volume]:

[
  [1700000000000, 2400.0, 2420.0, 2390.0, 2410.0, 150000],
  [1700000060000, 2410.0, 2430.0, 2405.0, 2425.0, 80000]
]

time is the bar's open timestamp in epoch milliseconds — the same unit as from/to above, so a bar's time falls directly within [from, to). The one argument in a different unit is intervalSeconds, which is seconds as its name says.

Live ticks (marketDataStreamer)

Stream<String> marketDataStreamer(String symbols);

symbols is a JSON-encoded list of symbol IDs to subscribe to. The SDK calls this again with the complete new list every time the subscribed set changes (symbol switch, option chain opened, scalper panel added), and cancels its listener on the previous stream. Resubscribe your feed to exactly the ids passed, and return a broadcast stream — a single-subscription stream crashes on the second call with Bad state: Stream has already been listened to.

Each emitted event is a JSON-encoded array of tick objects:

[
  {
    "symbolId": "RELIANCE", "ltp": 2411.5, "ltq": 100, "chng": 11.5, "chngPer": 0.48,
    "ltt": 1700001234000, "OI": 125000, "oiChng": 2500, "oiChngPer": 2.04,
    "vwap": 2408.2, "vol": 1500000, "volDelta": 5000, "lcl": 2200.0, "ucl": 2600.0,
    "dayClose": 2400.0
  }
]

For option symbols, also include the greeks flat on the same tick object (not nested under a greeks key):

{ "symbolId": "NIFTY24SEP25000CE", "ltp": 142.3, "ltt": 1700001234000, "itm": "true", "iv": 18.4, "delta": 0.52, "gamma": 0.004, "theta": -12.1, "rho": 3.2, "vega": 9.8, "highIV": 21.0, "lowIV": 15.2 }

Order book (web only)

The web order pad's Market Depth panel reads the order book from the same tick objects. Add these fields to a symbol's tick to feed it; native hosts can leave them out.

{
  "symbolId": "NIFTY24SEP25000CE", "ltp": 205.55, "ltt": 1700001234000, "vol": 7029373,
  "bids": [{ "price": 205.5, "qty": 1300, "orders": 6 }],
  "asks": [{ "price": 205.6, "qty": 910, "orders": 4 }],
  "totalBuyQty": 3895, "totalSellQty": 3395, "open": 189.0, "high": 212.4, "low": 181.2,
  "prevClose": 190.1, "avgTradePrice": 187.87, "ltq": 75
}

Each book is a full snapshot, not a delta. A tick without bids/asks keeps the last book shown, so you can send book updates and price-only ticks separately. The panel's volume and last trade time come from vol and ltt. If no book arrives within 10 seconds of opening the panel, it shows "No data available".

Symbol search & navigation

Stream<String> searchSymbolsStreamer(String query);

searchSymbolsStreamer is called once per debounced keystroke; query is the raw search text (e.g. "RELI"). Emits the same JSON shape as optionSymbols above (array of symbol objects) — a single result (or "[]") is enough:

[
  { "id": "RELIANCE", "name": "Reliance Industries", "lotSize": 1, "precision": 2, "tickSize": 0.05, "exchange": "NSE" }
]

Results are shown in the chart's own symbol search UI (the search box in the chart header) — there's no separate integration point for rendering them on your side.

chartInterfaceForSymbol

Called any time the chart needs to pivot to a different symbol without a full host-driven reinit — an option chain cell tap, a symbol search result, the CE/PE or Spot/Fut swap toggle, or (web terminal) a tile's layout role changing. symbolJson is the target symbol, same shape as symbolInfo.

ChartInterface? chartInterfaceForSymbol(String symbolJson) {
  try {
    final symbol = jsonDecode(symbolJson);
    final symbolId = symbol is Map<String, dynamic> ? symbol['id']?.toString() : null;
    if (symbolId == null || symbolId.isEmpty) return null;

    // A new instance scoped to the target symbol, reusing this host's own
    // config (stream rate, storage key prefix, etc).
    return YourChartInterface(symbolId: symbolId, storageKey: '$storageKey:$symbolId');
  } catch (_) {
    return null;
  }
}

Return a ChartInterface configured for that symbol, or null to disable navigation. null is silent: tapping a symbol search result or an option-chain row simply does nothing, and the search panel stays open.

The SDK never disposes the instances you return here — only the one you passed to NxtChartPage. Track them and close their streams yourself, for example from your original instance's dispose().