Market Data

use tigeropen::config::ClientConfig;
use tigeropen::model::quote_requests::BriefRequest;
use tigeropen::quote::QuoteClient;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let config = ClientConfig::builder().build()?;
    // v0.5.0+: use from_config() directly — no need to create HttpClient manually
    let qc = QuoteClient::from_config(config);

    // Get US market status
    let states = qc.get_market_state("US").await?;
    println!("US market state: {:?}", states);

    // Get real-time quotes
    let briefs = qc.get_real_time_quote(BriefRequest {
        symbols: Some(vec!["AAPL".to_string(), "TSLA".to_string()]),
        ..Default::default()
    }).await?;
    for b in &briefs {
        println!("{} latest_price={}", b.symbol, b.latest_price);
    }

    // Get daily candlestick data (v0.5.0+: multi-symbol slice)
    let klines = qc.get_kline(&["AAPL", "TSLA"], "day").await?;
    for k in &klines {
        println!("{} bars={}", k.symbol, k.items.len());
    }

    Ok(())
}

pub async fn get_market_state(&self, market: &str) -> Result<Vec<MarketState>, TigerError>

let states = qc.get_market_state("US").await?;
for s in &states {
    println!("{}: {} openTime={}", s.market, s.market_status, s.open_time);
}

{ "market": "US" }

[
  {
    "market": "US",
    "status": "trading",
    "openTime": 1735020600000,
    "closeTime": 1735044000000,
    "timezone": "America/New_York"
  }
]

pub async fn get_trading_calendar(&self, req: TradingCalendarRequest) -> Result<Vec<TradingCalendar>, TigerError>

use tigeropen::model::quote_requests::TradingCalendarRequest;

let calendar = qc.get_trading_calendar(TradingCalendarRequest {
    market: Some("US".to_string()),
    begin_date: Some("2025-01-01".to_string()),
    end_date: Some("2025-12-31".to_string()),
    ..Default::default()
}).await?;

pub async fn grab_quote_permission(&self) -> Result<Vec<QuotePermission>, TigerError>

let perms = qc.grab_quote_permission().await?;
for p in &perms {
    println!("{} expires_at={}", p.name, p.expire_at);
}

[
  { "name": "usStockQuote", "expireAt": 1735042800000 },
  { "name": "hkStockQuote", "expireAt": 1735042800000 }
]

pub async fn get_kline_quota(&self) -> Result<KlineQuota, TigerError>

let quota = qc.get_kline_quota().await?;
println!("used={} total={}", quota.used, quota.total);

pub async fn get_symbols(&self, req: SymbolsRequest) -> Result<Vec<String>, TigerError>

use tigeropen::model::quote_requests::SymbolsRequest;

let symbols = qc.get_symbols(SymbolsRequest {
    market: Some("US".to_string()),
    ..Default::default()
}).await?;
println!("total={}", symbols.len());

pub async fn get_symbol_names(&self, req: SymbolNamesRequest) -> Result<Vec<SymbolName>, TigerError>

let names = qc.get_symbol_names(SymbolNamesRequest {
    symbols: Some(vec!["AAPL".to_string(), "TSLA".to_string()]),
    ..Default::default()
}).await?;
for n in &names {
    println!("{} {}", n.symbol, n.name);
}

pub async fn get_trade_metas(&self, req: TradeMetasRequest) -> Result<Vec<TradeMeta>, TigerError>

let metas = qc.get_trade_metas(TradeMetasRequest {
    symbols: Some(vec!["AAPL".to_string()]),
    ..Default::default()
}).await?;
for m in &metas {
    println!("{} lot_size={} min_tick={}", m.symbol, m.lot_size, m.min_tick);
}

pub async fn get_real_time_quote(&self, req: BriefRequest) -> Result<Vec<Brief>, TigerError>

use tigeropen::model::quote_requests::BriefRequest;

let briefs = qc.get_real_time_quote(BriefRequest {
    symbols: Some(vec!["AAPL".to_string(), "TSLA".to_string()]),
    ..Default::default()
}).await?;
for b in &briefs {
    println!("{}: latest_price={}", b.symbol, b.latest_price);
}

{ "symbols": ["AAPL", "TSLA"] }

[
  {
    "symbol": "AAPL",
    "market": "US",
    "name": "Apple Inc.",
    "latestPrice": 227.52,
    "preClose": 225.01,
    "change": 2.51,
    "changePercentage": 1.115,
    "volume": 62345678,
    "amount": 14189233280.0,
    "open": 225.50,
    "high": 228.10,
    "low": 224.80,
    "timestamp": 1735042800000
  },
  {
    "symbol": "TSLA",
    "market": "US",
    "name": "Tesla Inc.",
    "latestPrice": 410.44,
    "preClose": 403.84,
    "change": 6.60,
    "changePercentage": 1.634,
    "volume": 98765432,
    "amount": 40542123456.0,
    "open": 405.00,
    "high": 415.20,
    "low": 402.30,
    "timestamp": 1735042800000
  }
]

pub async fn get_delayed_quote(&self, req: BriefRequest) -> Result<Vec<Brief>, TigerError>

let briefs = qc.get_delayed_quote(BriefRequest {
    symbols: Some(vec!["AAPL".to_string()]),
    ..Default::default()
}).await?;

pub async fn get_kline(&self, symbols: &[&str], period: &str) -> Result<Vec<Kline>, TigerError>

let daily = qc.get_kline(&["AAPL", "TSLA"], "day").await?;
for k in &daily {
    for bar in &k.items {
        println!("{} O={} H={} L={} C={}", k.symbol, bar.open, bar.high, bar.low, bar.close);
    }
}

{ "symbols": ["AAPL"], "period": "day" }

[
  {
    "symbol": "AAPL",
    "period": "day",
    "items": [
      {
        "time": 1734912000000,
        "open": 222.56,
        "high": 225.72,
        "low": 222.11,
        "close": 225.01,
        "volume": 55234100
      },
      {
        "time": 1734998400000,
        "open": 225.50,
        "high": 228.10,
        "low": 224.80,
        "close": 227.52,
        "volume": 62345678
      }
    ]
  }
]

pub async fn get_timeline(&self, symbols: &[&str]) -> Result<Vec<Timeline>, TigerError>

let timelines = qc.get_timeline(&["AAPL"]).await?;
for tl in &timelines {
    let count = tl.intraday.as_ref().map(|b| b.items.len()).unwrap_or(0);
    println!("{} intraday_points={} preClose={}", tl.symbol, count, tl.pre_close);
}

{ "symbols": ["AAPL"] }

{
  "symbol": "AAPL",
  "items": [
    {
      "time": 1735020600000,
      "price": 225.50,
      "volume": 3021456,
      "avgPrice": 225.48
    },
    {
      "time": 1735020660000,
      "price": 225.80,
      "volume": 1234567,
      "avgPrice": 225.55
    }
  ]
}

pub async fn get_timeline_history(&self, req: TimelineHistoryRequest) -> Result<Vec<Timeline>, TigerError>

use tigeropen::model::quote_requests::TimelineHistoryRequest;

let tl = qc.get_timeline_history(TimelineHistoryRequest {
    symbols: Some(vec!["AAPL".to_string()]),
    date: Some("2025-09-01".to_string()),
    ..Default::default()
}).await?;

pub async fn get_trade_tick(&self, req: TradeTickRequest) -> Result<Vec<TradeTick>, TigerError>

use tigeropen::model::quote_requests::TradeTickRequest;

let ticks = qc.get_trade_tick(TradeTickRequest {
    symbols: Some(vec!["AAPL".to_string()]),
    ..Default::default()
}).await?;
for t in &ticks {
    println!("{} ticks={}", t.symbol, t.items.len());
}

{ "symbols": ["AAPL"] }

{
  "symbol": "AAPL",
  "items": [
    {
      "time": 1735042780000,
      "price": 227.52,
      "volume": 100,
      "type": "BUY"
    },
    {
      "time": 1735042781000,
      "price": 227.50,
      "volume": 200,
      "type": "SELL"
    }
  ]
}

pub async fn get_quote_depth(&self, req: DepthQuoteRequest) -> Result<Vec<Depth>, TigerError>

use tigeropen::model::quote_requests::DepthQuoteRequest;

let depths = qc.get_quote_depth(DepthQuoteRequest {
    symbols: Some(vec!["AAPL".to_string()]),
    market: Some("US".to_string()),
    ..Default::default()
}).await?;
if let Some(d) = depths.first() {
    println!("{}: asks={} bids={}", d.symbol, d.asks.len(), d.bids.len());
}

pub async fn get_capital_flow(
    &self,
    symbol: &str,
    market: &str,
    period: &str,
) -> Result<Option<CapitalFlow>, TigerError>

if let Some(cf) = qc.get_capital_flow("AAPL", "US", "day").await? {
    println!("{} period={} rows={}", cf.symbol, cf.period, cf.items.len());
}

{ "symbol": "AAPL", "market": "US", "period": "day" }

{
  "symbol": "AAPL",
  "inflow": 8234567890,
  "outflow": 7123456789,
  "netInflow": 1111111101,
  "largeOrderInflow": 5123456789,
  "largeOrderOutflow": 4012345678,
  "mediumOrderInflow": 2012345678,
  "smallOrderInflow": 1098765432,
  "timestamp": 1735042800000
}

pub async fn get_capital_distribution(
    &self,
    symbol: &str,
    market: &str,
) -> Result<Option<CapitalDistribution>, TigerError>

if let Some(cd) = qc.get_capital_distribution("AAPL", "US").await? {
    println!("{} netInflow={}", cd.symbol, cd.net_inflow);
}

{ "symbol": "AAPL", "market": "US" }

{
  "symbol": "AAPL",
  "netInflow": 1111111101,
  "inAll": 8234567890,
  "inBig": 5123456789,
  "inMid": 2012345678,
  "inSmall": 1098765432,
  "outAll": 7123456789,
  "outBig": 4012345678,
  "outMid": 1912345678,
  "outSmall": 1198765432
}

pub async fn get_trade_rank(&self, req: TradeRankRequest) -> Result<Vec<TradeRankItem>, TigerError>

let rank = qc.get_trade_rank(TradeRankRequest {
    market: "HK".to_string(),
    ..Default::default()
}).await?;
for r in rank.iter().take(10) {
    println!("{} {} amount={}", r.symbol, r.name, r.amount);
}

pub async fn get_short_interest(&self, req: ShortInterestRequest) -> Result<Vec<ShortInterest>, TigerError>

let si = qc.get_short_interest(ShortInterestRequest {
    symbols: Some(vec!["TSLA".to_string()]),
    ..Default::default()
}).await?;

pub async fn get_stock_broker(&self, req: StockBrokerRequest) -> Result<Vec<StockBroker>, TigerError>

let sb = qc.get_stock_broker(StockBrokerRequest {
    symbol: "00700".to_string(),
    limit: Some(40),
    ..Default::default()
}).await?;
if let Some(b) = sb.first() {
    println!("{} ask_levels={} bid_levels={}", b.symbol, b.level_ask_list.len(), b.level_bid_list.len());
}

pub async fn get_stock_industry(&self, req: StockIndustryRequest) -> Result<Vec<StockIndustry>, TigerError>

let si = qc.get_stock_industry(StockIndustryRequest {
    symbol: "AAPL".to_string(),
    market: Some("US".to_string()),
    ..Default::default()
}).await?;

pub async fn get_option_expiration(&self, symbols: &[&str]) -> Result<Vec<OptionExpiration>, TigerError>

let exps = qc.get_option_expiration(&["AAPL"]).await?;
if let Some(e) = exps.first() {
    for date in &e.dates {
        println!("Expiry: {}", date);
    }
}

{ "symbols": ["AAPL"] }

[
  {
    "symbol": "AAPL",
    "dates": ["2025-01-17", "2025-02-21", "2025-03-21"],
    "timestamps": [1737081600000, 1740096000000, 1742515200000],
    "periods": ["weekly", "monthly", "monthly"]
  }
]

pub async fn get_option_symbols(&self, req: OptionSymbolsRequest) -> Result<Vec<String>, TigerError>

let syms = qc.get_option_symbols(OptionSymbolsRequest {
    market: Some("US".to_string()),
    ..Default::default()
}).await?;

pub async fn get_option_chain(&self, req: OptionChainRequest) -> Result<Vec<OptionChain>, TigerError>

use tigeropen::model::quote_requests::{OptionChainItem, OptionChainRequest};

let chain = qc.get_option_chain(OptionChainRequest::new(vec![
    OptionChainItem::from_date("AAPL", "2025-01-17")?,
])).await?;
if let Some(c) = chain.first() {
    println!("{} rows={}", c.symbol, c.items.len());
    for row in &c.items {
        if let Some(call) = &row.call {
            println!("call {} strike={}", call.identifier, call.strike);
        }
    }
}

{ "option_basic": [{ "symbol": "AAPL", "expiry": 1737072000000 }] }

[
  {
    "strike": 220.0,
    "callSymbol": "AAPL  250117C00220000",
    "putSymbol": "AAPL  250117P00220000",
    "callLatestPrice": 9.50,
    "putLatestPrice": 2.10,
    "callImpliedVolatility": 0.285,
    "putImpliedVolatility": 0.312
  }
]

pub async fn get_option_quote(&self, req: OptionQuoteRequest) -> Result<Vec<OptionBrief>, TigerError>

use tigeropen::model::quote_requests::{OptionContractItem, OptionQuoteRequest};

let briefs = qc.get_option_quote(OptionQuoteRequest::new(vec![
    OptionContractItem::from_occ("AAPL  250117C00150000")?,
])).await?;
for b in &briefs {
    println!("{} latest_price={}", b.symbol, b.latest_price);
}

{
  "option_basic": [
    { "symbol": "AAPL", "expiry": 1737072000000, "right": "CALL", "strike": "150.0" }
  ]
}

[
  {
    "identifier": "AAPL  250117C00220000",
    "latestPrice": 9.50,
    "preClose": 9.10,
    "change": 0.40,
    "impliedVolatility": 0.285,
    "delta": 0.612,
    "gamma": 0.028,
    "theta": -0.085,
    "vega": 0.156,
    "openInterest": 12540,
    "volume": 3820
  }
]

pub async fn get_option_kline(&self, req: OptionKlineRequest) -> Result<Vec<OptionKline>, TigerError>

use tigeropen::model::quote_requests::{OptionKlineItem, OptionKlineRequest};

// Single contract with time range
let mut item = OptionKlineItem::from_occ("AAPL  250117C00150000", "day")?;
item.begin_time = Some(begin_ms);
item.limit = Some(60);

let klines = qc.get_option_kline(OptionKlineRequest {
    option_query: Some(vec![item]),
    ..Default::default()
}).await?;
for k in &klines {
    println!("bars={}", k.items.len());
}

{
  "option_query": [
    { "symbol": "AAPL", "expiry": 1737072000000, "right": "CALL", "strike": 150.0, "period": "day" }
  ]
}

[
  {
    "symbol": "AAPL  250117C00150000",
    "period": "day",
    "items": [
      { "time": 1734912000000, "open": 8.80, "high": 9.60, "low": 8.70, "close": 9.10, "volume": 2100 },
      { "time": 1734998400000, "open": 9.10, "high": 9.80, "low": 9.00, "close": 9.50, "volume": 3820 }
    ]
  }
]

pub async fn get_option_trade_ticks(&self, req: OptionTradeTickRequest) -> Result<Vec<TradeTick>, TigerError>

let ticks = qc.get_option_trade_ticks(OptionTradeTickRequest {
    contracts: vec![OptionQueryItem {
        symbol: "AAPL".to_string(),
        expiry: 1750291200000,
        strike: "200".to_string(),
        right: "CALL".to_string(),
        ..Default::default()
    }],
    ..Default::default()
}).await?;

pub async fn get_option_timeline(&self, req: OptionTimelineRequest) -> Result<Vec<Timeline>, TigerError>

let tl = qc.get_option_timeline(OptionTimelineRequest {
    option_query: vec![/* OptionQueryItem */],
    ..Default::default()
}).await?;

pub async fn get_option_depth(&self, req: OptionDepthRequest) -> Result<Vec<Depth>, TigerError>

let depths = qc.get_option_depth(OptionDepthRequest {
    option_basic: vec![/* OptionQueryItem */],
    ..Default::default()
}).await?;

pub async fn get_option_analysis(&self, req: OptionAnalysisRequest) -> Result<Vec<OptionAnalysis>, TigerError>

let res = qc.get_option_analysis(OptionAnalysisRequest {
    symbols: Some(vec!["AAPL".to_string()]),
    market: Some("US".to_string()),
    ..Default::default()
}).await?;

pub async fn get_future_exchange(&self) -> Result<Vec<FutureExchange>, TigerError>

let exchanges = qc.get_future_exchange().await?;
for ex in &exchanges {
    println!("{}: {}", ex.code, ex.name);
}

[
  { "code": "CME", "name": "Chicago Mercantile Exchange", "zoneId": "America/Chicago" },
  { "code": "CBOT", "name": "Chicago Board of Trade", "zoneId": "America/Chicago" },
  { "code": "NYMEX", "name": "New York Mercantile Exchange", "zoneId": "America/New_York" },
  { "code": "HKEX", "name": "Hong Kong Exchanges and Clearing", "zoneId": "Asia/Hong_Kong" }
]

pub async fn get_future_contracts(&self, exchange_code: &str) -> Result<Vec<FutureContractInfo>, TigerError>

let contracts = qc.get_future_contracts("CME").await?;
for c in &contracts {
    println!("{} {}", c.contract_code, c.name);
}

{ "exchange_code": "CME" }

[
  {
    "contractCode": "ES2506",
    "name": "E-mini S&P 500",
    "multiplier": 50,
    "currency": "USD",
    "minTick": 0.25,
    "exchange": "CME"
  }
]

pub async fn get_future_contract(&self, req: FutureContractRequest) -> Result<Option<FutureContractInfo>, TigerError>

let contract = qc.get_future_contract(FutureContractRequest {
    contract_code: Some("CL2609".to_string()),
    ..Default::default()
}).await?;

pub async fn get_all_future_contracts(&self, req: AllFutureContractsRequest) -> Result<Vec<FutureContractInfo>, TigerError>

let contracts = qc.get_all_future_contracts(AllFutureContractsRequest {
    type_: Some("CL".to_string()),
    ..Default::default()
}).await?;

pub async fn get_current_future_contract(&self, req: FutureContractRequest) -> Result<Option<FutureContractInfo>, TigerError>

let c = qc.get_current_future_contract(FutureContractRequest {
    type_: Some("CL".to_string()),
    ..Default::default()
}).await?;
if let Some(contract) = c {
    println!("current main: {}", contract.contract_code);
}

pub async fn get_future_continuous_contracts(&self, req: FutureContractsRequest) -> Result<Vec<FutureContractInfo>, TigerError>

pub async fn get_future_history_main_contract(&self, req: FutureHistoryRequest) -> Result<Vec<FutureContractInfo>, TigerError>

pub async fn get_future_real_time_quote(&self, req: FutureBriefRequest) -> Result<Vec<FutureQuote>, TigerError>

use tigeropen::model::quote_requests::FutureBriefRequest;

let quotes = qc.get_future_real_time_quote(FutureBriefRequest {
    contract_codes: Some(vec!["ES2506".to_string(), "NQ2506".to_string()]),
    ..Default::default()
}).await?;
for q in &quotes {
    println!("{} latest_price={}", q.contract_code, q.latest_price);
}

pub async fn get_future_kline(&self, req: FutureKlineRequest) -> Result<Vec<FutureKline>, TigerError>

use tigeropen::model::quote::FutureKlineRequest;

let klines = qc.get_future_kline(FutureKlineRequest {
    contract_codes: vec!["ES2506".into()],
    period: "day".into(),
    begin_time: -1,
    end_time: -1,
    limit: None,
    page_token: None,
}).await?;

for k in &klines {
    println!("bars={}", k.items.len());
}

{ "contract_codes": ["ES2506"], "period": "day", "begin_time": -1, "end_time": -1 }

[
  {
    "items": [
      { "time": 1734912000000, "open": 5870.00, "high": 5900.00, "low": 5860.00, "close": 5895.25, "volume": 1023456 },
      { "time": 1734998400000, "open": 5900.00, "high": 5935.00, "low": 5895.00, "close": 5920.50, "volume": 1234567 }
    ]
  }
]

pub async fn get_future_trade_ticks(&self, req: FutureTradeTickRequest) -> Result<Vec<TradeTick>, TigerError>

pub async fn get_future_depth(&self, req: FutureDepthRequest) -> Result<Vec<Depth>, TigerError>

pub async fn get_future_trading_times(&self, req: FutureTradingTimesRequest) -> Result<Vec<FutureTradingTime>, TigerError>

pub async fn get_fund_symbols(&self, req: FundSymbolsRequest) -> Result<Vec<String>, TigerError>

let symbols = qc.get_fund_symbols(FundSymbolsRequest {
    ..Default::default()
}).await?;

pub async fn get_fund_contracts(&self, req: FundContractsRequest) -> Result<Vec<FundContract>, TigerError>

let contracts = qc.get_fund_contracts(FundContractsRequest {
    symbols: vec!["SPY".to_string()],
    ..Default::default()
}).await?;

pub async fn get_fund_quote(&self, req: FundQuoteRequest) -> Result<Vec<FundQuote>, TigerError>

let quotes = qc.get_fund_quote(FundQuoteRequest {
    symbols: vec!["SPY".to_string()],
    ..Default::default()
}).await?;

pub async fn get_fund_history_quote(&self, req: FundHistoryQuoteRequest) -> Result<Vec<FundHistoryQuote>, TigerError>

pub async fn get_warrant_quote(&self, req: WarrantBriefsRequest) -> Result<Vec<Brief>, TigerError>

pub async fn get_warrant_filter(&self, req: WarrantFilterRequest) -> Result<Vec<WarrantFilterResult>, TigerError>

pub async fn get_industry_list(&self, req: IndustryListRequest) -> Result<Vec<Industry>, TigerError>

let industries = qc.get_industry_list(IndustryListRequest {
    industry_level: "GSECTOR".to_string(),
    ..Default::default()
}).await?;

pub async fn get_industry_stocks(&self, req: IndustryStocksRequest) -> Result<Vec<String>, TigerError>

let stocks = qc.get_industry_stocks(IndustryStocksRequest {
    industry_id: "10".to_string(),  // Energy sector
    market: Some("US".to_string()),
    ..Default::default()
}).await?;

pub async fn market_scanner(&self, req: MarketScannerRequest) -> Result<Option<ScannerResult>, TigerError>

use tigeropen::model::quote::MarketScannerRequest;

if let Some(r) = qc.market_scanner(MarketScannerRequest {
    market: "US".into(),
    page: Some(0),
    page_size: Some(10),
    ..Default::default()
}).await? {
    println!("page={}/{} total={} items={}", r.page, r.total_page, r.total_count, r.items.len());
}

{ "market": "US", "page": 0, "page_size": 10 }

[
  {
    "symbol": "AAPL",
    "name": "Apple Inc.",
    "latestPrice": 227.52,
    "changePercentage": 1.115,
    "marketCap": 3420000000000,
    "volume": 62345678
  },
  {
    "symbol": "NVDA",
    "name": "NVIDIA Corporation",
    "latestPrice": 138.85,
    "changePercentage": 3.240,
    "marketCap": 3390000000000,
    "volume": 185432100
  }
]

pub async fn get_market_scanner_tags(&self, req: MarketScannerTagsRequest) -> Result<Vec<ScannerTag>, TigerError>

let tags = qc.get_market_scanner_tags(MarketScannerTagsRequest {
    market: "US".to_string(),
    multi_tags_fields: vec!["sector".to_string()],
    ..Default::default()
}).await?;