const apidata = require("pix-apidata");

const API_KEY  = "your-api-key-here";
const API_HOST = "apidata.accelpix.in";
const SCHEME   = "https";

async function start() {
  await apidata.initialize(API_KEY, API_HOST, SCHEME);
  // ✅ Connection ready — all other calls go here
  console.log("Connected and ready!");
}

start().catch(console.error);

apidata.initialize(API_KEY, API_HOST, SCHEME)
  .then(() => {
    console.log("✅ Connected");
    // All subscriptions and history calls go here
  })
  .catch((err) => {
    console.error("❌ Connection failed:", err);
  });

apidata.callbacks.onTrade((msg) => {
  console.log(`[TRADE] ${msg.ticker} @ ₹${msg.price}`);
  console.log(`  Qty: ${msg.qty} | Volume: ${msg.volume} | OI: ${msg.oi}`);
  console.log(`  Time: ${msg.time} | Segment: ${msg.segmentId}`);
});

{
  "id": 0,
  "ticker": "BANKNIFTY-1",
  "segmentId": 2,
  "time": "2024-01-18T15:29:52.000Z",
  "price": 46560,
  "qty": 300,
  "volume": 7499525,
  "oi": 3215240,
  "kind": "T"
}

apidata.callbacks.onTradeSnapshot((msg) => {
  // Seed your UI with the latest known price
  updateUI(msg.ticker, msg.price, msg.volume);
});

apidata.callbacks.onBest((msg) => {
  console.log(`[BEST] ${msg.ticker}`);
  console.log(`  Bid: ₹${msg.bidPrice} × ${msg.bidQty} qty`);
  console.log(`  Ask: ₹${msg.askPrice} × ${msg.askQty} qty`);
});

{
  "ticker": "NIFTY-1", "kind": "B",
  "bidPrice": 21780, "bidQty": 350,
  "askPrice": 21782, "askQty": 250
}

// Fires once on subscription — current OHLC snapshot
apidata.callbacks.onRefsSnapshot((msg) => {
  console.log(`[OHLC Snap] ${msg.ticker}`);
  console.log(`  O:${msg.open} H:${msg.high} L:${msg.low} C:${msg.close} OI:${msg.oi}`);
  console.log(`  Upper Band:${msg.upperBand}  Lower Band:${msg.lowerBand}`); // EQ only
});

// Fires when O/H/L/C/OI values are updated during session
apidata.callbacks.onRefs((msg) => {
  console.log(`[Ref Update] ${msg.ticker} price=${msg.price} kind=${msg.kind}`);
});

apidata.callbacks.onGreeks((msg) => {
  console.log(`[Greeks] ${msg.ticker}`);
  console.log(`  IV: ${msg.iv?.toFixed(4)}  IVVWAP: ${msg.ivvwap?.toFixed(4)}`);
  console.log(`  Δ Delta: ${msg.delta?.toFixed(4)}`);
  console.log(`  Γ Gamma: ${msg.gamma?.toFixed(6)}`);
  console.log(`  Θ Theta: ${msg.theta?.toFixed(2)}`);
  console.log(`  ν Vega:  ${msg.vega?.toFixed(4)}`);
});

// Fires once at subscription with current values
apidata.callbacks.onGreekSnapshot((msg) => {
  console.log("Greeks Snapshot:", msg.ticker, "IV:", msg.iv);
});

apidata.callbacks.onConnected(() => {
  console.log("✅ WebSocket connected to Accelpix");
});

apidata.callbacks.onClosed((err) => {
  console.error("❌ Connection closed:", err);
  // Re-initialize and re-subscribe here if you want auto-reconnect
  setTimeout(() => start(), 5000); // retry after 5s
});

// ── ALL updates: Trade + Best + Refs ─────────────────
await apidata.stream.subscribeAll(['NIFTY-1', 'BANKNIFTY-1', 'TCS']);

// ── Trade ticks only (lower bandwidth) ───────────────
await apidata.stream.subscribeTrade(['NIFTY-1', 'BANKNIFTY-1']);

// ── Bid/Ask + Refs only ───────────────────────────────
await apidata.stream.subscribeBestAndRefs(['NIFTY-1', 'INFY']);

// ── Option Greeks — use full option ticker ────────────
await apidata.stream.subscribeGreeks(['NIFTY2411822200CE', 'NIFTY2411821800PE']);

// ── Full option chain for one expiry ─────────────────
await apidata.stream.subscribeOptionChain('NIFTY', '20240118');  // expiry: YYYYMMDD

// ── Range chain: N strikes above+below spot ──────────
// 10 strikes = 10 CE + 10 PE above + 10 CE + 10 PE below = 40 contracts
await apidata.stream.subscribeOptionChainRange('NIFTY', '20240118', 10);

// ── Greeks + chain range ─────────────────────────────
await apidata.stream.subscribeGreeksChainRange('NIFTY', '20240118', 5);

// ── Full segment (all entitled symbols) ──────────────
const needSnapshot = false;
await apidata.stream.subscribeSegments(needSnapshot);

await apidata.stream.unsubscribeAll(['NIFTY-1', 'BANKNIFTY-1']);
await apidata.stream.unsubscribeOptionChain('NIFTY', '20240118');
await apidata.stream.unsubscribeGreeks(['NIFTY2411822200CE']);
await apidata.stream.unsubscribeGreeksChain('NIFTY', '20240118');

// Continuous contract EOD
// Parameters: ticker, startDate (YYYYMMDD), endDate (YYYYMMDD)
let eod = await apidata.history.getEod("NIFTY-1", "20240112", "20240118");
console.log(eod); // Array of {td, op, hp, lp, cp, vol, oi}

// Contract-specific EOD (with exact expiry date)
// Parameters: underlying, startDate, endDate, contractExpiry (YYYYMMDD)
let eodC = await apidata.history.getEodContract(
  "NIFTY", "20240109", "20240118", "20240125"
);

// Supported resolutions: "1", "3", "5", "7", "10" (minutes)

// 5-minute bars, multiple days
let bars5m = await apidata.history.getIntraEod("NIFTY-1", "20240112", "20240118", "5");

// 1-minute bars, single day (use today's date for live aggregation)
let bars1m = await apidata.history.getIntraEod("BANKNIFTY-1", "20240118", "20240118", "1");

// 10-minute bars
let bars10m = await apidata.history.getIntraEod("TCS", "20240110", "20240115", "10");

// Contract-specific intraday bars
let cBars = await apidata.history.getIntraEodContract(
  "NIFTY", "20240109", "20240118", "20240125", "5"
);

// All ticks from a given datetime to live/latest
// Parameters: ticker, fromDateTime ("YYYYMMDD HH:mm:ss")
let ticks = await apidata.history.getBackTicks("BANKNIFTY-1", "20240118 15:00:00");
// Returns all trade ticks from 15:00 to present
console.log(`Got ${ticks.length} ticks`);

const apidata = require('pix-apidata');

// ── CONFIG ──────────────────────────────────────────────────────
const API_KEY  = "your-api-key-here";
const API_HOST = "apidata.accelpix.in";
const SCHEME   = "https";

// ── STEP 1: Register ALL callbacks BEFORE initialize ─────────────
apidata.callbacks.onConnected(() => console.log("✅ Connected to Accelpix"));
apidata.callbacks.onClosed((err) => {
  console.error("❌ Disconnected:", err);
  // Optional: add reconnect logic here
});

apidata.callbacks.onTrade((t) =>
  console.log(`[TRADE] ${t.ticker.padEnd(20)} ₹${t.price} | Vol:${t.volume} OI:${t.oi}`)
);
apidata.callbacks.onTradeSnapshot((t) =>
  console.log(`[SNAP]  ${t.ticker.padEnd(20)} ₹${t.price} (last known price)`)
);
apidata.callbacks.onBest((b) =>
  console.log(`[BEST]  ${b.ticker.padEnd(20)} Bid:₹${b.bidPrice}×${b.bidQty} Ask:₹${b.askPrice}×${b.askQty}`)
);
apidata.callbacks.onRefsSnapshot((r) =>
  console.log(`[OHLC]  ${r.ticker.padEnd(20)} O:${r.open} H:${r.high} L:${r.low} C:${r.close}`)
);
apidata.callbacks.onRefs((r) =>
  console.log(`[REFS]  ${r.ticker} price=${r.price} kind=${r.kind}`)
);
apidata.callbacks.onGreeks((g) =>
  console.log(`[GREEK] ${g.ticker} IV:${g.iv?.toFixed(4)} Δ:${g.delta?.toFixed(4)} Θ:${g.theta?.toFixed(2)}`)
);
apidata.callbacks.onGreekSnapshot((g) =>
  console.log(`[GSNAP] ${g.ticker} IV:${g.iv?.toFixed(4)}`)
);

// ── STEP 2: Initialize ───────────────────────────────────────────
apidata.initialize(API_KEY, API_HOST, SCHEME)
  .then(async () => {

    // ── STEP 3: Pull historical data ─────────────────────────────
    console.log("Fetching EOD data...");
    const eod = await apidata.history.getEod('NIFTY-1', '20240112', '20240116');
    console.log(`📊 EOD: ${eod.length} days`, eod[0]);

    console.log("Fetching 5-min bars...");
    const intra = await apidata.history.getIntraEod('NIFTY-1', '20240112', '20240112', '5');
    console.log(`📉 5-min bars: ${intra.length} bars`, intra[0]);

    // ── STEP 4: Subscribe to live streams ────────────────────────
    console.log("Subscribing to live data...");
    await apidata.stream.subscribeAll(['NIFTY-1', 'BANKNIFTY-1']);
    await apidata.stream.subscribeGreeks(['NIFTY2411822200CE', 'NIFTY2411821800PE']);
    await apidata.stream.subscribeOptionChainRange('NIFTY', '20240118', 7);

    console.log("🚀 Live streams active. Waiting for data...");
  })
  .catch((err) => console.error("❌ Initialization failed:", err));

import asyncio
from pix_apidata import *

# Create API instance and event loop
api        = apidata_lib.ApiData()
event_loop = asyncio.get_event_loop()

API_KEY  = "your-api-key-here"
API_HOST = "apidata.accelpix.in"

async def main():
    await api.initialize(API_KEY, API_HOST)
    # ✅ Ready — all subscriptions and history calls go here
    print("Connected!")

def on_trade(msg):
    t = apidata_models.Trade(msg)
    print(f"[TRADE] {t.ticker} @ ₹{t.price}")
    print(f"  Qty: {t.qty} | Volume: {t.volume} | OI: {t.oi}")
    print(f"  Time: {t.time} | Segment: {t.segmentId}")

api.on_trade_update(on_trade)

def on_trade_snapshot(msg):
    t = apidata_models.Trade(msg)
    print(f"[SNAP] {t.ticker} last known price: ₹{t.price}")

api.on_tradeSnapshot_update(on_trade_snapshot)

def on_best(msg):
    b = apidata_models.Best(msg)
    print(f"[BEST] {b.ticker}")
    print(f"  Bid: ₹{b.bidPrice} × {b.bidQty} | Ask: ₹{b.askPrice} × {b.askQty}")

api.on_best_update(on_best)

def on_refs(msg):
    r = apidata_models.Refs(msg)
    print(f"[REFS] {r.ticker} price={r.price} kind={r.kind}")

def on_srefs(msg):
    s = apidata_models.RefsSnapshot(msg)
    print(f"[OHLC] {s.ticker} O:{s.open} H:{s.high} L:{s.low} C:{s.close} OI:{s.oi}")
    print(f"       Upper Band: {s.upperBand}  Lower Band: {s.lowerBand}")  # EQ only

api.on_refs_update(on_refs)
api.on_srefs_update(on_srefs)

def on_greeks(msg):
    g = apidata_models.Greeks(msg)
    print(f"[GREEK] {g.ticker}")
    print(f"  IV: {g.iv:.4f}   IVVWAP: {g.ivvwap:.4f}")
    print(f"  Δ Delta: {g.delta:.4f}")
    print(f"  Γ Gamma: {g.gamma:.6f}")
    print(f"  Θ Theta: {g.theta:.2f}")
    print(f"  ν Vega:  {g.vega:.4f}")

def on_greeks_snapshot(msg):
    g = apidata_models.Greeks(msg)
    print(f"[GSNAP] {g.ticker} IV:{g.iv:.4f}")

api.on_greeks_update(on_greeks)
api.on_greekSnapshot_update(on_greeks_snapshot)

def on_connected():
    print("✅ Connected to Accelpix")

def on_stopped():
    print("❌ Connection stopped — re-initialize to reconnect")

api.on_connection_started(on_connected)
api.on_connection_stopped(on_stopped)

# All updates: Trade + Best + Refs
await api.subscribeAll(['NIFTY-1', 'BANKNIFTY-1', 'NIFTY 50'])

# Trade ticks only
await api.subscribeTrade(['NIFTY-1', 'BANKNIFTY-1'])

# Bid/Ask + Refs only
await api.subscribeBestAndRefs(['NIFTY-1', 'BANKNIFTY-1'])

# Option Greeks for specific options
await api.subscribeGreeks(['NIFTY2220318500CE', 'NIFTY2220318000PE'])

# Full option chain for one expiry date (YYYYMMDD)
await api.subscribeOptionChain('BANKNIFTY', '20220901')

# Range chain: N strikes above and below spot
await api.subscribeOptionChainRange('NIFTY', '20220901', 10)

# Full segment subscription
await api.subscribeSegments(False)

await api.unsubscribeAll(['NIFTY-1', 'BANKNIFTY-1'])
await api.unsubscribeOptionChain('NIFTY', '20220609')
await api.unsubscribeGreeks(['NIFTY2220318500CE'])
await api.unsubscribeGreeksChain('NIFTY', '20220609')

# EOD — continuous contract
eod = await api.get_eod("NIFTY-1", "20200828", "20200901")
print(f"Got {len(eod)} EOD bars")

# EOD — contract specific (include expiry date)
eod_c = await api.get_eod_contract("NIFTY", "20200828", "20200901", "20201029")

# Intraday bars — 5-minute resolution
intra5 = await api.get_intra_eod("NIFTY-1", "20210603", "20210604", "5")

# Intraday bars — 1-minute resolution (today only)
intra1 = await api.get_intra_eod("BANKNIFTY-1", "20240118", "20240118", "1")

# Intraday — contract specific
intra_c = await api.get_intra_eod_contract(
    "NIFTY", "20200828", "20200901", "20201029", "5"
)

# Tick data — from a specific datetime to live
# Format: "YYYYMMDD HH:mm:ss"
ticks = await api.get_back_ticks("BANKNIFTY-1", "20201016 15:00:00")
print(f"Got {len(ticks)} ticks")

bars = await api.get_intra_eod("NIFTY-1", "20240115", "20240115", "5")

for bar in bars:
    print(f"{bar['td']}  O:{bar['op']}  H:{bar['hp']}  L:{bar['lp']}  C:{bar['cp']}  V:{bar['vol']}")

# Convert to pandas DataFrame (install with: pip install pandas)
import pandas as pd
df = pd.DataFrame(bars)
df['td'] = pd.to_datetime(df['td'])
df.set_index('td', inplace=True)
print(df.head())

import asyncio
from pix_apidata import *

# ── CONFIG ────────────────────────────────────────────────────────
API_KEY  = "your-api-key-here"
API_HOST = "apidata.accelpix.in"

# ── CREATE INSTANCE ───────────────────────────────────────────────
api        = apidata_lib.ApiData()
event_loop = asyncio.get_event_loop()

# ── CALLBACK HANDLERS ─────────────────────────────────────────────
def on_trade(msg):
    t = apidata_models.Trade(msg)
    print(f"[TRADE] {t.ticker:20} ₹{t.price} | Vol:{t.volume} OI:{t.oi}")

def on_trade_snapshot(msg):
    t = apidata_models.Trade(msg)
    print(f"[SNAP]  {t.ticker:20} ₹{t.price} (last known)")

def on_best(msg):
    b = apidata_models.Best(msg)
    print(f"[BEST]  Bid:₹{b.bidPrice}×{b.bidQty}  Ask:₹{b.askPrice}×{b.askQty}")

def on_refs(msg):
    r = apidata_models.Refs(msg)
    print(f"[REFS]  {r.ticker} price={r.price}")

def on_srefs(msg):
    s = apidata_models.RefsSnapshot(msg)
    print(f"[OHLC]  {s.ticker} O:{s.open} H:{s.high} L:{s.low} C:{s.close}")

def on_greeks(msg):
    g = apidata_models.Greeks(msg)
    print(f"[GREEK] {g.ticker} IV:{g.iv:.4f} Δ:{g.delta:.4f} Θ:{g.theta:.2f}")

def on_greeks_snapshot(msg):
    g = apidata_models.Greeks(msg)
    print(f"[GSNAP] {g.ticker} IV:{g.iv:.4f}")

async def main():
    # STEP 1: Register connection callbacks
    api.on_connection_started(lambda: print("✅ Connected to Accelpix"))
    api.on_connection_stopped(lambda: print("❌ Disconnected"))

    # STEP 2: Register data callbacks
    api.on_trade_update(on_trade)
    api.on_tradeSnapshot_update(on_trade_snapshot)
    api.on_best_update(on_best)
    api.on_refs_update(on_refs)
    api.on_srefs_update(on_srefs)
    api.on_greeks_update(on_greeks)
    api.on_greekSnapshot_update(on_greeks_snapshot)

    # STEP 3: Initialize — always await this before anything else
    await api.initialize(API_KEY, API_HOST)

    # STEP 4: Pull historical data
    print("Fetching 5-min bars...")
    bars = await api.get_intra_eod("NIFTY-1", "20210603", "20210604", "5")
    print(f"📊 Got {len(bars)} bars. First: {bars[0] if bars else 'none'}")

    # STEP 5: Subscribe to live data
    print("Subscribing to live data...")
    await api.subscribeAll(['NIFTY-1', 'BANKNIFTY-1'])
    await api.subscribeGreeks(['NIFTY2220318500CE'])
    await api.subscribeOptionChainRange('NIFTY', '20220901', 10)

    print("🚀 Live. Waiting for data (Ctrl+C to stop)...")

# ── ENTRY POINT ───────────────────────────────────────────────────
event_loop.create_task(main())
try:
    event_loop.run_forever()
except KeyboardInterrupt:
    print("\n👋 Stopped.")
finally:
    event_loop.close()

var client = new ApiClient();
Task<bool> InitializeAsync(string apiKey, string apiHost, string protoScheme = "http", CancellationToken cancellationToken = default);

using NetApiClient;

const string ApiKey  = "your-api-key-here";
const string ApiHost = "apidata.accelpix.in";

var client = new ApiClient();
bool ok = await client.InitializeAsync(ApiKey, ApiHost, "https");

if (!ok)
{
    Console.WriteLine("Unable to connect — check your API key/host.");
    return;
}
// ✅ Connection ready — subscriptions and history calls go here
Console.WriteLine("Connected and ready!");

client.TradeUpdate += (Tick t) =>
{
    Console.WriteLine($"[TRADE] {t.Ticker} @ ₹{t.Price}");
    Console.WriteLine($"  Qty: {t.Qty} | Volume: {t.Volume} | OI: {t.Oi}");
};

client.BestUpdate += (Best b) =>
{
    Console.WriteLine($"[BEST] {b.Ticker}");
    Console.WriteLine($"  Bid: ₹{b.BidPrice} × {b.BidQty} qty");
    Console.WriteLine($"  Ask: ₹{b.AskPrice} × {b.AskQty} qty");
};

// Fires once on subscription — current OHLC snapshot
client.RefsSnapshotUpdate += (Refs r) =>
{
    Console.WriteLine($"[OHLC Snap] {r.Ticker}");
    Console.WriteLine($"  O:{r.Open} H:{r.High} L:{r.Low} C:{r.Close} OI:{r.Oi}");
    Console.WriteLine($"  Upper Band:{r.UpperBand}  Lower Band:{r.LowerBand}"); // EQ only
};

// Fires when a single O/H/L/C/OI/Avg value updates during the session
client.RefsUpdate += (Sref s) =>
{
    Console.WriteLine($"[Ref Update] {s.Ticker} price={s.Price} kind={s.Kind}");
};

client.Connected += () =>
    Console.WriteLine("✅ Connected to Accelpix");

client.Closed += (string reason) =>
{
    Console.WriteLine($"❌ Connection closed: {reason}");
    // Re-initialize and re-subscribe here if you want auto-reconnect
};

// ── Best bid/ask + OHLC refs (RefsSnapshotUpdate, RefsUpdate, BestUpdate) ──
await client.SubscribeAsync(new List<string> { "NIFTY-1", "BANKNIFTY-1", "TCS" });

// ── Trade ticks only (lower bandwidth) — fires TradeUpdate ────────────────
await client.SubscribeTradeAsync(new List<string> { "NIFTY-1", "BANKNIFTY-1" });

// ── Full option chain for one expiry (YYYYMMDD) ───────────────────────────
await client.SubscribeOptionChainAsync("NIFTY", "20240118");

// ── Range chain: N strikes above + below spot ─────────────────────────────
// 10 strikes = 10 CE + 10 PE above + 10 CE + 10 PE below = 40 contracts
await client.SubscribeOptionChainRangeAsync("NIFTY", "20240118", 10);

await client.UnSubscribeOptionChainAsync("NIFTY", "20240118");

// Cleanly close the SignalR connection when your app shuts down
await client.DisposeAsync();

// Continuous contract EOD — returns List<Hd>
List<Hd> eod = await client.GetEodAsync("NIFTY-1", "20240112", "20240118");
Console.WriteLine($"Got {eod.Count} EOD bars");

// Contract-specific EOD (with exact expiry date)
List<Hd> eodC = await client.GetEodContractAsync(
    "NIFTY", "20240109", "20240118", "20240125"
);

// Supported resolutions: "1", "3", "5", "7", "10" (minutes). Default is "5".

// 5-minute bars, multiple days
List<Hd> bars5m = await client.GetIntraEodAsync("NIFTY-1", "20240112", "20240118", "5");

// 1-minute bars, single day (use today's date for live aggregation)
List<Hd> bars1m = await client.GetIntraEodAsync("BANKNIFTY-1", "20240118", "20240118", "1");

// Contract-specific intraday bars
List<Hd> cBars = await client.GetIntraEodContractAsync(
    "NIFTY", "20240109", "20240118", "20240125", "5"
);

// All ticks from a given datetime to live/latest — returns List<Htd>
// Parameters: ticker, lastDateTime ("YYYYMMDD HH:mm:ss")
List<Htd> ticks = await client.GetBackTicksAsync("BANKNIFTY-1", "20240118 15:00:00");
Console.WriteLine($"Got {ticks.Count} ticks");

List<Hd> bars = await client.GetIntraEodAsync("NIFTY-1", "20240115", "20240115", "5");

foreach (var bar in bars)
{
    Console.WriteLine(
        $"{bar.Td:yyyy-MM-dd HH:mm}  O:{bar.Op}  H:{bar.Hp}  L:{bar.Lp}  C:{bar.Cp}  V:{bar.Vol}");
}

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using NetApiClient;
using FeedData.Models;

class Program
{
    private const string ApiKey  = "your-api-key-here";
    private const string ApiHost = "apidata.accelpix.in";

    static async Task Main(string[] args)
    {
        var client = new ApiClient();

        // ── STEP 1: Register ALL callbacks BEFORE subscribing ─────────────
        client.Connected += () => Console.WriteLine("✅ Connected to Accelpix");
        client.Closed    += reason => Console.WriteLine($"❌ Disconnected: {reason}");

        client.TradeUpdate += (Tick t) =>
            Console.WriteLine($"[TRADE] {t.Ticker,-20} ₹{t.Price} | Vol:{t.Volume} OI:{t.Oi}");

        client.BestUpdate += (Best b) =>
            Console.WriteLine($"[BEST]  {b.Ticker,-20} Bid:₹{b.BidPrice}×{b.BidQty} Ask:₹{b.AskPrice}×{b.AskQty}");

        client.RefsSnapshotUpdate += (Refs r) =>
            Console.WriteLine($"[OHLC]  {r.Ticker,-20} O:{r.Open} H:{r.High} L:{r.Low} C:{r.Close}");

        client.RefsUpdate += (Sref s) =>
            Console.WriteLine($"[REFS]  {s.Ticker} price={s.Price} kind={s.Kind}");

        // ── STEP 2: Initialize — always await this before anything else ──
        bool ok = await client.InitializeAsync(ApiKey, ApiHost, "https");
        if (!ok)
        {
            Console.WriteLine("Unable to connect — check your API key/host.");
            return;
        }

        // ── STEP 3: Pull historical data ──────────────────────────────────
        Console.WriteLine("Fetching EOD data...");
        var eod = await client.GetEodAsync("NIFTY-1", "20240112", "20240118");
        Console.WriteLine($"📊 EOD: {eod.Count} bars");

        Console.WriteLine("Fetching 5-min bars...");
        var intra = await client.GetIntraEodAsync("NIFTY-1", "20240112", "20240112", "5");
        Console.WriteLine($"📉 5-min bars: {intra.Count} bars");

        // ── STEP 4: Subscribe to live streams ─────────────────────────────
        Console.WriteLine("Subscribing to live data...");
        await client.SubscribeAsync(new List<string> { "NIFTY-1", "BANKNIFTY-1" });
        await client.SubscribeTradeAsync(new List<string> { "NIFTY-1", "BANKNIFTY-1" });
        await client.SubscribeOptionChainRangeAsync("NIFTY", "20240118", 7);

        Console.WriteLine("🚀 Live streams active. Press any key to exit...");
        Console.ReadKey();

        await client.DisposeAsync();
    }
}

http://apidata.accelpix.in/api/fda/rest

{base_url}/{endpoint}?api_token=YOUR_URL_ENCODED_KEY

import requests
import urllib.parse

BASE = "http://apidata.accelpix.in/api/fda/rest"
KEY  = urllib.parse.quote("your_api_key_here", safe="")

# ── EOD Data ─────────────────────────────────────────
eod = requests.get(f"{BASE}/NIFTY-1/20240116/20240118?api_token={KEY}").json()
print(f"EOD bars: {len(eod)}")
for bar in eod:
    print(f"  {bar['td']}  O:{bar['op']}  H:{bar['hp']}  L:{bar['lp']}  C:{bar['cp']}")

# ── 5-min Intraday ───────────────────────────────────
intra = requests.get(f"{BASE}/NIFTY-1/20240116/20240118/5?api_token={KEY}").json()
print(f"5-min bars: {len(intra)}")

# ── Real-time Quotes ─────────────────────────────────
quotes = requests.post(
    f"{BASE}/quote?api_token={KEY}",
    json=["NIFTY-1", "BANKNIFTY-1", "TCS", "RELIANCE"]
).json()

print("\n=== Live Quotes ===")
for q in quotes:
    print(f"{q['tkr']:20}  LTP: ₹{q['pr']:10}  Chg: {q['chgpc']:+.2f}%  Vol: {q['vol']}")

# ── Symbol Master ────────────────────────────────────
master_url = "https://apidata.accelpix.in/api/hsd/Masters/3?fmt=json"
master = requests.get(master_url).json()
print(f"\nMaster: {len(master)} instruments")

# Find all NIFTY weekly options expiring on 18-Jan-2024
jan18_opts = [x for x in master
              if x.get('utkr') == 'NIFTY'
              and '20240118' in x.get('exp', '')]
print(f"NIFTY 18-Jan options: {len(jan18_opts)}")
for opt in jan18_opts[:5]:
    print(f"  {opt['tkr']}  strike:{opt.get('sp')}  lot:{opt.get('lot')}")

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using System.Collections.Generic;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;

class AccelpixClient
{
    static readonly string BASE = "http://apidata.accelpix.in/api/fda/rest";
    static readonly string KEY  = Uri.EscapeDataString("your_api_key_here");
    static readonly HttpClient http = new HttpClient();

    static async Task Main()
    {
        // ── EOD Data
        var eodJson = await http.GetStringAsync(
            $"{BASE}/NIFTY-1/20240116/20240118?api_token={KEY}"
        );
        var eod = JArray.Parse(eodJson);
        Console.WriteLine($"EOD bars: {eod.Count}");
        foreach (var bar in eod)
            Console.WriteLine($"  {bar["td"]}  C:{bar["cp"]}");

        // ── 5-min Intraday
        var intraJson = await http.GetStringAsync(
            $"{BASE}/NIFTY-1/20240116/20240118/5?api_token={KEY}"
        );
        var intra = JArray.Parse(intraJson);
        Console.WriteLine($"5-min bars: {intra.Count}");

        // ── Quotes POST
        var symbols = new List<string> { "NIFTY-1", "BANKNIFTY-1", "TCS" };
        var payload  = new StringContent(
            JsonConvert.SerializeObject(symbols),
            Encoding.UTF8, "application/json"
        );
        var qResp   = await http.PostAsync($"{BASE}/quote?api_token={KEY}", payload);
        var qJson   = await qResp.Content.ReadAsStringAsync();
        var quotes  = JArray.Parse(qJson);

        Console.WriteLine("\n=== Live Quotes ===");
        foreach (var q in quotes)
            Console.WriteLine($"{q["tkr"],-20} LTP: ₹{q["pr"]}  Chg: {q["chgpc"]:+0.00}%");
    }
}

https://greeks.accelpix.in?apiKey={YOUR_API_KEY}

socket.emit("subscribe", {
  symbols: ["NIFTY25MAY24550PE"]
});

socket.emit("unsubscribe", {
  symbols: ["NIFTY25MAY24550PE"]
});

{
  "id": 2061691,
  "kind": "T",
  "ticker": "NIFTY25MAY24700CE",
  "segmentId": 2,
  "time": "2025-05-15T10:22:02.000Z",
  "price": 261,
  "qty": 75,
  "volume": 1624950,
  "oi": 2034600
}

{
  "ticker": "NIFTY25MAY24700CE",
  "iv": 0.1746,
  "delta": 0.4714,
  "gamma": 0.00047,
  "theta": -4369.10,
  "vega": 19.19,
  "rho": 4.33,
  "vanna": -0.0803,
  "charm": 1.38,
  "speed": -0.000009,
  "zomma": -0.00268,
  "color": -0.00617,
  "volga": 83.52,
  "tgr": -33.20,
  "dtr": -43.80,
  "tv": 300,
  "timestamp": 1747285593971
}

{
  "error": "Invalid API key or exceeded subscription limit"
}

// Install with: npm install socket.io-client
const { io } = require("socket.io-client");

// Replace with your actual API key
const API_KEY = "YOUR_API_KEY";

// Connect to the WebSocket server
const socket = io("https://greeks.accelpix.in", {
  query: { apiKey: API_KEY },
  transports: ["websocket"]
});

// Symbol(s) to subscribe
const symbolsToSubscribe = ["NIFTY25JUN24700CE"];

socket.on("connect", () => {
  console.log("✅ Connected to Accelpix WebSocket");
  socket.emit("subscribe", { symbols: symbolsToSubscribe });
  console.log(`📡 Subscribed to symbols: ${symbolsToSubscribe.join(", ")}`);
});

socket.on("trade", (data) => { console.log("📈 Trade Data:", data); });
socket.on("greeks", (data) => { console.log("📊 Greeks Data:", data); });
socket.on("errors", (err) => { console.error("❌ Error:", err); });
socket.on("disconnect", () => { console.log("🔌 Disconnected from server"); });

#pip install "python-socketio[client]"
import socketio
import time

API_KEY = "YOUR_API_KEY"
sio = socketio.Client()

@sio.event
def connect():
    print("✅ Connected to server")
    sio.emit("subscribe", {"symbols": ["NIFTY25JUN24550PE"]})

@sio.event
def disconnect():
    print("❌ Disconnected from server")

@sio.on("trade")
def on_trade(data):
    print("Trade:", data)

@sio.on("greeks")
def on_greeks(data):
    print("Greeks:", data)

@sio.on("errors")
def on_errors(data):
    print("Error:", data)

if __name__ == "__main__":
    try:
        sio.connect(
            f"https://greeks.accelpix.in?apiKey={API_KEY}",
            transports=["websocket"]
        )
        print("Press Ctrl+C to exit.")
        while True:
            time.sleep(1)
    except KeyboardInterrupt:
        sio.disconnect()

?apikey={YOUR_API_KEY}