feat: login-free Stockbit intraday and quote provider

Read Stockbit's public symbol page (__NEXT_DATA__) with a plain ureq
request and an honest user agent: `stocks intraday` (today by the
minute, any provider), `--provider stockbit` quotes with the best
bid/offer only while the market is open, and MCP `get_intraday`.

- UPSTREAMBLOCKED error (exit 4) for a CDN 403; never retried
- requests paced 1 s apart across idx processes, 5 s snapshot cache
- global --provider flag (yahoo, msn, stockbit)
- roadmap: L1 ships from Stockbit; depth stays a login follow-on

crates/idx-core/src/api/mock.rs

@@ -1,10 +1,10 @@
 //! Fixture-backed provider for tests, enabled by the `testing` feature and
 //! `IDX_USE_MOCK_PROVIDER`. Release builds do not contain it.
 
-use super::types::{Bar, Fundamentals, Interval, Period, Quote};
+use super::types::{Bar, Fundamentals, Interval, Intraday, Period, Quote};
 use super::{
-    BrokerSummaryProvider, FundamentalsProvider, HistoryProvider, QuoteProvider,
-    TradingSummaryProvider, idx, ipot, msn, yahoo,
+    BrokerSummaryProvider, FundamentalsProvider, HistoryProvider, IntradayProvider, QuoteProvider,
+    TradingSummaryProvider, idx, ipot, msn, stockbit, yahoo,
 };
 use crate::broker::types::{BrokerBoard, BrokerInvestor, BrokerQuery};
 use crate::config::ProviderKind;
@@ -45,6 +45,10 @@ impl MockProvider {
         match provider {
             ProviderKind::Yahoo => Self::from_yahoo_fixtures(history_verbose),
             ProviderKind::Msn => Self::from_msn_fixtures(),
+            // `MockStockbitProvider` serves Stockbit; it has no history.
+            ProviderKind::Stockbit => Self::with_error(IdxError::Unsupported(
+                "Stockbit serves no price history".to_string(),
+            )),
         }
     }
 
@@ -131,6 +135,57 @@ impl HistoryProvider for MockProvider {
     }
 }
 
+/// Stockbit symbol pages from `tests/fixtures/stockbit_symbol_<code>.html`;
+/// a code without a fixture is Stockbit's 404. `IDX_MOCK_STOCKBIT_STATUS`
+/// (e.g. `403`) answers that HTTP status instead, and `IDX_MOCK_ERROR` fails
+/// as for the other providers.
+pub struct MockStockbitProvider;
+
+impl MockStockbitProvider {
+    fn snapshot(&self, symbol: &str) -> Result<Intraday, IdxError> {
+        if std::env::var("IDX_MOCK_ERROR").is_ok() {
+            return Err(IdxError::ProviderUnavailable);
+        }
+        if let Ok(status) = std::env::var("IDX_MOCK_STOCKBIT_STATUS") {
+            return Err(stockbit::status_error(
+                status.parse().unwrap_or(500),
+                symbol,
+            ));
+        }
+        let code = stockbit::stockbit_code(symbol)?;
+        let path = format!(
+            "tests/fixtures/stockbit_symbol_{}.html",
+            code.to_ascii_lowercase()
+        );
+        match std::fs::read_to_string(path) {
+            Ok(html) => stockbit::parse_symbol_page(symbol, &html),
+            Err(_) => Err(stockbit::status_error(404, symbol)),
+        }
+    }
+}
+
+impl QuoteProvider for MockStockbitProvider {
+    fn quote(&self, symbol: &str) -> Result<Quote, IdxError> {
+        let mut quote = self.snapshot(symbol)?.quote;
+        // Quotes are judged against the clock (behind the session, a week
+        // old); a fixed trade time would make their output age.
+        quote.as_of = None;
+        Ok(quote)
+    }
+}
+
+impl FundamentalsProvider for MockStockbitProvider {
+    fn fundamentals(&self, symbol: &str) -> Result<Fundamentals, IdxError> {
+        Err(stockbit::fundamentals_unsupported(symbol))
+    }
+}
+
+impl IntradayProvider for MockStockbitProvider {
+    fn intraday(&self, symbol: &str) -> Result<Intraday, IdxError> {
+        self.snapshot(symbol)
+    }
+}
+
 /// Broker summaries from `tests/fixtures/ipot_brokersummary_<code>_<from>
 /// [_<to>][_<investor>_<board>].html`; a query without a fixture reads as an
 /// unknown code.

crates/idx-core/src/api/mod.rs

@@ -3,6 +3,7 @@ pub mod ipot;
 #[cfg(feature = "testing")]
 pub mod mock;
 pub mod msn;
+pub mod stockbit;
 pub mod types;
 pub mod yahoo;
 
@@ -13,7 +14,7 @@ use crate::config::{HistoryProviderKind, ProviderKind};
 use crate::error::IdxError;
 use types::{
     Bar, CompanyProfile, EarningsReport, FinancialStatements, Fundamentals, InsightData, Interval,
-    NewsItem, Period, Quote, SentimentData,
+    Intraday, NewsItem, Period, Quote, SentimentData,
 };
 
 /// IDX trades in Western Indonesia Time (WIB, UTC+7, no DST). Providers stamp
@@ -64,6 +65,13 @@ pub trait TradingSummaryProvider {
     ) -> Result<Vec<crate::flow::types::StockDay>, IdxError>;
 }
 
+/// Today's session of one IDX symbol: quote and price per minute. Served by
+/// Stockbit's public page whichever market provider is selected.
+pub trait IntradayProvider {
+    /// `symbol` is resolved, e.g. `BBCA.JK`.
+    fn intraday(&self, symbol: &str) -> Result<Intraday, IdxError>;
+}
+
 pub trait FundamentalsProvider {
     fn fundamentals(&self, symbol: &str) -> Result<Fundamentals, IdxError>;
 }
@@ -221,7 +229,10 @@ fn mock_enabled() -> bool {
 
 #[cfg(feature = "testing")]
 fn mock_market(provider: ProviderKind) -> Option<Box<dyn MarketDataProvider>> {
-    Some(Box::new(mock::MockProvider::from_fixtures(provider)))
+    match provider {
+        ProviderKind::Stockbit => Some(Box::new(mock::MockStockbitProvider)),
+        _ => Some(Box::new(mock::MockProvider::from_fixtures(provider))),
+    }
 }
 
 #[cfg(not(feature = "testing"))]
@@ -274,6 +285,18 @@ fn build_selected_provider(
             news: Some(Box::new(msn::MsnProvider::new(verbose))),
             screener: Some(Box::new(msn::MsnProvider::new(verbose))),
         },
+        // Quotes only; history falls back to Yahoo (see `history_source`).
+        ProviderKind::Stockbit => SelectedProvider {
+            kind: ProviderKind::Stockbit,
+            market: mock.unwrap_or_else(|| Box::new(stockbit::StockbitProvider::new())),
+            profile: None,
+            financials: None,
+            earnings: None,
+            sentiment: None,
+            insights: None,
+            news: None,
+            screener: None,
+        },
     }
 }
 
@@ -297,6 +320,14 @@ pub fn trading_summary_provider() -> Box<dyn TradingSummaryProvider> {
     Box::new(idx::IdxSiteProvider)
 }
 
+pub fn intraday_provider() -> Box<dyn IntradayProvider> {
+    #[cfg(feature = "testing")]
+    if mock::enabled() {
+        return Box::new(mock::MockStockbitProvider);
+    }
+    Box::new(stockbit::StockbitProvider::new())
+}
+
 /// Today in WIB, the date IDX trades on.
 pub(crate) fn today_wib() -> chrono::NaiveDate {
     #[cfg(feature = "testing")]
@@ -312,8 +343,7 @@ pub fn history_source(provider: ProviderKind, history_mode: HistoryProviderKind)
         HistoryProviderKind::Yahoo => ProviderKind::Yahoo,
         HistoryProviderKind::Msn => ProviderKind::Msn,
         HistoryProviderKind::Auto => match provider {
-            ProviderKind::Yahoo => ProviderKind::Yahoo,
-            ProviderKind::Msn => ProviderKind::Yahoo,
+            ProviderKind::Yahoo | ProviderKind::Msn | ProviderKind::Stockbit => ProviderKind::Yahoo,
         },
     }
 }
@@ -339,6 +369,9 @@ pub fn history_provider(
     match resolved {
         ProviderKind::Yahoo => Ok((resolved, Box::new(yahoo::YahooProvider::new(verbose)))),
         ProviderKind::Msn => Ok((resolved, Box::new(msn::MsnProvider::new(verbose)))),
+        ProviderKind::Stockbit => Err(IdxError::Unsupported(
+            "Stockbit serves no price history; use --history-provider yahoo or msn".to_string(),
+        )),
     }
 }
 

crates/idx-core/src/api/msn/map.rs

@@ -71,6 +71,10 @@ pub(super) fn parse_quote(symbol: &str, quotes: &[MsnQuote]) -> Result<Quote, Id
         avg_volume: round_u64(quote.average_volume),
         as_of: crate::api::parse_as_of(quote.time_last_traded.as_deref()),
         behind_session: false,
+        bid: None,
+        offer: None,
+        market_status: None,
+        session_note: None,
     })
 }
 
@@ -720,6 +724,10 @@ pub(super) fn parse_screener_results(raw: &RawScreenerResponse) -> Result<Vec<Qu
                 avg_volume: round_u64(q.average_volume),
                 as_of: crate::api::parse_as_of(q.time_last_traded.as_deref()),
                 behind_session: false,
+                bid: None,
+                offer: None,
+                market_status: None,
+                session_note: None,
             })
         })
         .collect();

crates/idx-core/src/api/stockbit/mod.rs

@@ -0,0 +1,193 @@
+//! Stockbit's public symbol page: a quote, the best bid/offer and today's
+//! price per minute for one IDX symbol, without a login or key.
+//!
+//! `GET https://stockbit.com/symbol/{CODE}` server-renders everything into
+//! the page's `__NEXT_DATA__` JSON (see `parse`). Stockbit's own JSON API
+//! (`exodus.stockbit.com`) needs a logged-in bearer token and is not used.
+//!
+//! Access rules this module keeps:
+//! - An honest user agent. CloudFront in front of the page answers a static
+//!   HTTP 403 to `curl/`, `axios/`, `Go-http-client/` and empty agents; it
+//!   does not fingerprint TLS, so no browser impersonation is involved.
+//! - One request per symbol, at least `MIN_INTERVAL` apart across every idx
+//!   process of the user (see `pace`), no retries, and a 403 surfaces as
+//!   `UPSTREAMBLOCKED` at once.
+//! - Stockbit's terms describe its market data as delayed at least 10
+//!   minutes and for personal use; frontends say so.
+
+mod parse;
+
+use std::fs::{File, OpenOptions};
+use std::io::{Read, Seek, SeekFrom, Write};
+use std::sync::Mutex;
+use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};
+
+pub use parse::{parse_symbol_page, status_error, stockbit_code};
+
+use super::types::{Fundamentals, Intraday, Quote};
+use super::{FundamentalsProvider, IntradayProvider, QuoteProvider};
+use crate::error::IdxError;
+
+pub const SOURCE: &str = "stockbit";
+/// Identifies idx-cli and where to reach its maintainers.
+pub const USER_AGENT: &str = concat!(
+    "idx-cli/",
+    env!("CARGO_PKG_VERSION"),
+    " (+",
+    env!("CARGO_PKG_REPOSITORY"),
+    ")"
+);
+/// Longest a snapshot is served from cache: enough to coalesce a burst (an
+/// agent asking for a quote and the intraday series), short enough that a
+/// session view stays current.
+pub(crate) const CACHE_TTL_SECS: u64 = 5;
+/// Least time between two requests to stockbit.com from one process.
+const MIN_INTERVAL: Duration = Duration::from_secs(1);
+const BASE_URL: &str = "https://stockbit.com/symbol/";
+
+pub struct StockbitProvider {
+    agent: ureq::Agent,
+}
+
+impl StockbitProvider {
+    pub fn new() -> Self {
+        let agent = ureq::Agent::config_builder()
+            .timeout_connect(Some(Duration::from_secs(5)))
+            .timeout_recv_body(Some(Duration::from_secs(10)))
+            // A server that stalls before sending headers must not hold a
+            // call (and an MCP call slot) forever.
+            .timeout_global(Some(Duration::from_secs(20)))
+            .build()
+            .into();
+        Self { agent }
+    }
+
+    /// The quote and today's series for a resolved symbol (`BBCA.JK`).
+    pub fn snapshot(&self, resolved: &str) -> Result<Intraday, IdxError> {
+        let code = stockbit_code(resolved)?;
+        let html = self.page(&code, resolved)?;
+        parse_symbol_page(resolved, &html)
+    }
+
+    fn page(&self, code: &str, resolved: &str) -> Result<String, IdxError> {
+        pace();
+        let response = self
+            .agent
+            .get(format!("{BASE_URL}{code}"))
+            .header("User-Agent", USER_AGENT)
+            .header("Accept", "text/html")
+            .call();
+        match response {
+            Ok(ok) => ok
+                .into_body()
+                .read_to_string()
+                .map_err(|e| IdxError::Http(format!("stockbit: {e}"))),
+            Err(ureq::Error::StatusCode(status)) => Err(status_error(status, resolved)),
+            Err(err) => Err(IdxError::Http(format!("stockbit: {err}"))),
+        }
+    }
+}
+
+impl Default for StockbitProvider {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+/// Waits until `MIN_INTERVAL` has passed since the previous request. Threads
+/// of one process queue on a mutex; separate processes (a shell loop of
+/// `idx` calls, a CLI beside idx-mcp) share the time of the last request in
+/// `<cache>/stockbit.pace` under an exclusive file lock. When that file is
+/// unusable, pacing is per process.
+fn pace() {
+    static LAST: Mutex<Option<Instant>> = Mutex::new(None);
+    let mut last = LAST.lock().unwrap_or_else(|poisoned| poisoned.into_inner());
+    if let Some(prev) = *last {
+        let wait = MIN_INTERVAL.saturating_sub(prev.elapsed());
+        if !wait.is_zero() {
+            std::thread::sleep(wait);
+        }
+    }
+    // Best effort: the in-process pacing above already holds.
+    let _ = pace_across_processes();
+    *last = Some(Instant::now());
+}
+
+fn pace_across_processes() -> std::io::Result<()> {
+    let dir = crate::cache::cache_dir().map_err(|e| std::io::Error::other(e.to_string()))?;
+    std::fs::create_dir_all(&dir)?;
+    let mut file = OpenOptions::new()
+        .read(true)
+        .write(true)
+        .create(true)
+        .truncate(false)
+        .open(dir.join("stockbit.pace"))?;
+    // Released when `file` is dropped, after the new time is written.
+    file.lock()?;
+    let mut raw = String::new();
+    file.read_to_string(&mut raw)?;
+    if let Ok(prev_ms) = raw.trim().parse::<u128>() {
+        // A clock that went backwards waits at most one interval.
+        let elapsed = now_ms().saturating_sub(prev_ms);
+        let wait = MIN_INTERVAL.as_millis().saturating_sub(elapsed);
+        if wait > 0 {
+            std::thread::sleep(Duration::from_millis(wait as u64));
+        }
+    }
+    stamp(&mut file)
+}
+
+fn stamp(file: &mut File) -> std::io::Result<()> {
+    file.set_len(0)?;
+    file.seek(SeekFrom::Start(0))?;
+    write!(file, "{}", now_ms())
+}
+
+fn now_ms() -> u128 {
+    SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .map_or(0, |d| d.as_millis())
+}
+
+impl QuoteProvider for StockbitProvider {
+    fn quote(&self, symbol: &str) -> Result<Quote, IdxError> {
+        self.snapshot(symbol).map(|day| day.quote)
+    }
+}
+
+impl FundamentalsProvider for StockbitProvider {
+    fn fundamentals(&self, symbol: &str) -> Result<Fundamentals, IdxError> {
+        Err(fundamentals_unsupported(symbol))
+    }
+}
+
+impl IntradayProvider for StockbitProvider {
+    fn intraday(&self, symbol: &str) -> Result<Intraday, IdxError> {
+        self.snapshot(symbol)
+    }
+}
+
+pub(crate) fn fundamentals_unsupported(symbol: &str) -> IdxError {
+    IdxError::Unsupported(format!(
+        "{symbol}: Stockbit has no fundamentals; command requires --provider msn or yahoo"
+    ))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::USER_AGENT;
+
+    /// CloudFront answers HTTP 403 to agents containing these (probed
+    /// 2026-10-22); the honest agent must never match one.
+    #[test]
+    fn user_agent_is_honest_and_not_on_the_cdn_blocklist() {
+        assert!(USER_AGENT.starts_with("idx-cli/"));
+        assert!(USER_AGENT.contains("github.com/0xrsydn/idx-cli"));
+        for blocked in ["curl/", "axios/", "Go-http-client/"] {
+            assert!(
+                !USER_AGENT.contains(blocked),
+                "{USER_AGENT} contains {blocked}"
+            );
+        }
+    }
+}

crates/idx-core/src/api/stockbit/parse.rs

@@ -0,0 +1,440 @@
+//! Pure parsing of a Stockbit symbol page: the `__NEXT_DATA__` JSON that
+//! Next.js renders into `https://stockbit.com/symbol/{CODE}`. No I/O.
+//!
+//! Shapes (recorded 2026-10-22 after the close, see
+//! `tests/fixtures/stockbit_symbol_*.html`):
+//! - `props.pageProps.company`: the quote. Numbers are mostly strings
+//!   (`price: "5175"`, an index `"5387.90478515625"`, `change: "+59.54"`),
+//!   `percentage` is a JSON number, `orderbook.{bid,offer}.price` is
+//!   `"5175.000000"` or `"N/A"`, `market_hour.status` is e.g. `close`, and
+//!   `status` is `STATUS_ACTIVE`, `STATUS_SUSPENDED` or `STATUS_DELISTED`.
+//!   `date`/`time` (`"22 Oct 2026"`, `"Thu 16:14"`) are the last trade only
+//!   when the stock traded: a suspended one carries today's date.
+//! - `props.pageProps.chart.prices[]`: one row per minute,
+//!   `formatted_date: "2026-10-22 16:14:00"` (WIB, no offset) and
+//!   `value: "5175"`. The first row is a synthetic anchor at the previous
+//!   close with an empty `formatted_date`. Per-minute OHLC and volume are
+//!   empty strings, so only the price is kept.
+//! - An unknown code renders the 404 page: `page: "/404"`, empty pageProps.
+
+use chrono::{DateTime, FixedOffset, NaiveDate, NaiveDateTime, NaiveTime, TimeZone};
+use serde::Deserialize;
+use serde_json::Value;
+
+use crate::api::idx_offset;
+use crate::api::types::{Intraday, IntradayPoint, Quote};
+use crate::error::IdxError;
+
+/// Stockbit's market status while continuous trading runs. Bid and offer are
+/// reported only then: outside it they are the closing book.
+const MARKET_OPEN: &str = "open";
+
+#[derive(Debug, Deserialize)]
+struct NextData {
+    page: String,
+    props: Props,
+}
+
+#[derive(Debug, Deserialize)]
+struct Props {
+    #[serde(rename = "pageProps", default)]
+    page_props: PageProps,
+}
+
+#[derive(Debug, Default, Deserialize)]
+struct PageProps {
+    company: Option<RawCompany>,
+    chart: Option<RawChart>,
+}
+
+#[derive(Debug, Deserialize)]
+struct RawCompany {
+    price: Value,
+    #[serde(default)]
+    previous: Value,
+    #[serde(default)]
+    change: Value,
+    #[serde(default)]
+    percentage: Value,
+    #[serde(default)]
+    volume: Value,
+    date: Option<String>,
+    time: Option<String>,
+    status: Option<String>,
+    orderbook: Option<RawOrderbook>,
+    market_hour: Option<RawMarketHour>,
+}
+
+#[derive(Debug, Deserialize)]
+struct RawOrderbook {
+    bid: Option<RawLevel>,
+    offer: Option<RawLevel>,
+}
+
+#[derive(Debug, Deserialize)]
+struct RawLevel {
+    #[serde(default)]
+    price: Value,
+}
+
+#[derive(Debug, Deserialize)]
+struct RawMarketHour {
+    status: Option<String>,
+}
+
+#[derive(Debug, Default, Deserialize)]
+struct RawChart {
+    #[serde(default)]
+    prices: Vec<RawPoint>,
+}
+
+#[derive(Debug, Deserialize)]
+struct RawPoint {
+    #[serde(default)]
+    formatted_date: String,
+    #[serde(default)]
+    value: Value,
+}
+
+/// Stockbit's code for a resolved symbol: `BBCA.JK` -> `BBCA`, and Yahoo's
+/// index tickers to Stockbit's (`^JKSE` -> `IHSG`, `^JKLQ45` -> `LQ45`).
+pub fn stockbit_code(resolved: &str) -> Result<String, IdxError> {
+    let unsupported = || {
+        IdxError::Unsupported(format!(
+            "{resolved}: Stockbit covers IDX (.JK) symbols only"
+        ))
+    };
+    let code = resolved.strip_suffix(".JK").ok_or_else(unsupported)?;
+    let code = match code.strip_prefix('^') {
+        Some("JKSE") => "IHSG",
+        Some("JKLQ45") => "LQ45",
+        Some(_) => return Err(unsupported()),
+        None => code,
+    };
+    if code.is_empty() || !code.chars().all(|c| c.is_ascii_alphanumeric()) {
+        return Err(unsupported());
+    }
+    Ok(code.to_string())
+}
+
+/// The error for a non-success HTTP status from stockbit.com. A 403 is
+/// CloudFront's static block page (it refuses some user agents outright),
+/// not a challenge, so nothing is retried.
+pub fn status_error(status: u16, resolved: &str) -> IdxError {
+    match status {
+        403 => IdxError::UpstreamBlocked(
+            "stockbit.com refused this client (HTTP 403 from its CDN); idx does not retry a \
+             block. Try again later or from another network; `--provider msn` serves quotes \
+             without Stockbit"
+                .to_string(),
+        ),
+        404 => IdxError::SymbolNotFound(resolved.to_string()),
+        429 => IdxError::RateLimited,
+        _ => IdxError::Http(format!("stockbit: HTTP {status}")),
+    }
+}
+
+/// The quote and today's per-minute prices from a symbol page, stamped with
+/// `resolved` (e.g. `BBCA.JK`).
+pub fn parse_symbol_page(resolved: &str, html: &str) -> Result<Intraday, IdxError> {
+    let data: NextData = serde_json::from_str(next_data(html)?)
+        .map_err(|e| layout_error(format!("__NEXT_DATA__ is not the expected JSON: {e}")))?;
+    if data.page == "/404" {
+        return Err(IdxError::SymbolNotFound(resolved.to_string()));
+    }
+    let company = data
+        .props
+        .page_props
+        .company
+        .ok_or_else(|| layout_error("no company in the page".to_string()))?;
+    let points = parse_points(&data.props.page_props.chart.unwrap_or_default())?;
+    let quote = parse_quote(resolved, &company)?;
+    Ok(Intraday { quote, points })
+}
+
+fn layout_error(detail: String) -> IdxError {
+    IdxError::ParseError(format!(
+        "stockbit symbol page: {detail} (the page layout changed?)"
+    ))
+}
+
+/// The JSON inside `<script id="__NEXT_DATA__" ...>...</script>`.
+fn next_data(html: &str) -> Result<&str, IdxError> {
+    let missing = || layout_error("no __NEXT_DATA__ script".to_string());
+    let tag = html.find("id=\"__NEXT_DATA__\"").ok_or_else(missing)?;
+    let start = tag + html[tag..].find('>').ok_or_else(missing)? + 1;
+    let len = html[start..].find("</script>").ok_or_else(missing)?;
+    Ok(&html[start..start + len])
+}
+
+fn parse_quote(resolved: &str, company: &RawCompany) -> Result<Quote, IdxError> {
+    let price = number(&company.price)
+        .ok_or_else(|| layout_error(format!("price {} is not a number", company.price)))?;
+    let price = price.round() as i64;
+    let prev_close = number(&company.previous).map(|p| p.round() as i64);
+    let change = number(&company.change)
+        .map(|c| c.round() as i64)
+        .or_else(|| prev_close.map(|prev| price - prev));
+    let volume = count(&company.volume);
+    let listing = company.status.as_deref().unwrap_or_default();
+    let market_status = company
+        .market_hour
+        .as_ref()
+        .and_then(|m| m.status.clone())
+        .filter(|s| !s.is_empty());
+    let open = market_status.as_deref() == Some(MARKET_OPEN);
+    let level = |side: Option<&RawLevel>| {
+        side.and_then(|l| number(&l.price))
+            .filter(|p| *p > 0.0)
+            .map(|p| p.round() as i64)
+    };
+    let book = company.orderbook.as_ref();
+    let (bid, offer) = if open {
+        (
+            level(book.and_then(|b| b.bid.as_ref())),
+            level(book.and_then(|b| b.offer.as_ref())),
+        )
+    } else {
+        (None, None)
+    };
+    let traded = volume.is_some_and(|v| v > 0);
+    let as_of = if listing == "STATUS_ACTIVE" && traded {
+        last_trade(company.date.as_deref(), company.time.as_deref())
+    } else {
+        None
+    };
+    // Facts about this symbol only; the market's state is `market_status`.
+    // An untraded stock can still have a flat chart at the previous close.
+    let session_note = match listing {
+        "STATUS_SUSPENDED" => Some("Stockbit lists the stock as suspended".to_string()),
+        "STATUS_DELISTED" => Some("Stockbit lists the stock as delisted".to_string()),
+        _ if volume == Some(0) => Some("no trades this session".to_string()),
+        _ => None,
+    };
+    Ok(Quote {
+        symbol: resolved.to_string(),
+        price,
+        change,
+        change_pct: number(&company.percentage),
+        volume,
+        market_cap: None,
+        week52_high: None,
+        week52_low: None,
+        week52_position: None,
+        range_signal: None,
+        prev_close,
+        avg_volume: None,
+        as_of,
+        behind_session: false,
+        bid,
+        offer,
+        market_status,
+        session_note,
+    })
+}
+
+/// Today's prices, oldest first, one per minute. The anchor row (no
+/// timestamp) is dropped; any other row that does not parse means the
+/// layout changed.
+fn parse_points(chart: &RawChart) -> Result<Vec<IntradayPoint>, IdxError> {
+    let mut points = Vec::with_capacity(chart.prices.len());
+    for row in &chart.prices {
+        if row.formatted_date.is_empty() {
+            continue;
+        }
+        let bad = || layout_error(format!("chart row {:?} {}", row.formatted_date, row.value));
+        let local = NaiveDateTime::parse_from_str(&row.formatted_date, "%Y-%m-%d %H:%M:%S")
+            .map_err(|_| bad())?;
+        let time = wib(local).ok_or_else(bad)?;
+        let price = number(&row.value).ok_or_else(bad)?;
+        points.push(IntradayPoint { time, price });
+    }
+    points.sort_by_key(|p| p.time);
+    // A repeated minute keeps its last row.
+    points.reverse();
+    points.dedup_by_key(|p| p.time);
+    points.reverse();
+    Ok(points)
+}
+
+/// `"22 Oct 2026"` and `"Thu 16:14"` as a WIB time.
+fn last_trade(date: Option<&str>, time: Option<&str>) -> Option<DateTime<FixedOffset>> {
+    let date = NaiveDate::parse_from_str(date?.trim(), "%d %b %Y").ok()?;
+    let clock = time?.trim().rsplit(' ').next()?;
+    let clock = NaiveTime::parse_from_str(clock, "%H:%M").ok()?;
+    wib(date.and_time(clock))
+}
+
+fn wib(local: NaiveDateTime) -> Option<DateTime<FixedOffset>> {
+    idx_offset().from_local_datetime(&local).single()
+}
+
+/// A JSON number or numeric string (`"+59.54"`, `"5175.000000"`); `"N/A"`,
+/// `"NA"` and empty strings are absent.
+fn number(value: &Value) -> Option<f64> {
+    let n = match value {
+        Value::Number(n) => n.as_f64()?,
+        Value::String(s) => s.trim().parse::<f64>().ok()?,
+        _ => return None,
+    };
+    n.is_finite().then_some(n)
+}
+
+fn count(value: &Value) -> Option<u64> {
+    match value {
+        Value::Number(n) => n.as_u64(),
+        Value::String(s) => s.trim().parse::<u64>().ok(),
+        _ => None,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn fixture(name: &str) -> String {
+        std::fs::read_to_string(format!(
+            "{}/tests/fixtures/{name}",
+            env!("CARGO_MANIFEST_DIR")
+        ))
+        .unwrap()
+    }
+
+    /// The recorded BBCA page with Stockbit's market status set to `status`.
+    fn bbca_with_status(status: &str) -> String {
+        let page = fixture("stockbit_symbol_bbca.html");
+        assert!(page.contains(r#""status":"close""#));
+        page.replace(r#""status":"close""#, &format!(r#""status":"{status}""#))
+    }
+
+    #[test]
+    fn closed_session_keeps_the_series_and_hides_the_closing_book() {
+        let day = parse_symbol_page("BBCA.JK", &fixture("stockbit_symbol_bbca.html")).unwrap();
+        let q = &day.quote;
+        assert_eq!(
+            (q.price, q.prev_close, q.change),
+            (5175, Some(5275), Some(-100))
+        );
+        assert_eq!(q.change_pct, Some(-1.9));
+        assert_eq!(q.volume, Some(286_928_500));
+        assert_eq!(q.market_status.as_deref(), Some("close"));
+        assert_eq!((q.bid, q.offer), (None, None));
+        assert_eq!(q.session_note, None);
+        assert_eq!(q.as_of.unwrap().to_rfc3339(), "2026-10-22T16:14:00+07:00");
+
+        // 336 rows less the anchor at the previous close.
+        assert_eq!(day.points.len(), 335);
+        let first = &day.points[0];
+        assert_eq!(first.time.to_rfc3339(), "2026-10-22T08:58:00+07:00");
+        assert_eq!(first.price, 5125.0);
+        let last = day.points.last().unwrap();
+        assert_eq!(last.time.to_rfc3339(), "2026-10-22T16:14:00+07:00");
+        assert_eq!(last.price, 5175.0);
+        assert!(day.points.windows(2).all(|w| w[0].time < w[1].time));
+    }
+
+    #[test]
+    fn open_market_reports_best_bid_and_offer() {
+        let day = parse_symbol_page("BBCA.JK", &bbca_with_status(MARKET_OPEN)).unwrap();
+        assert_eq!((day.quote.bid, day.quote.offer), (Some(5175), Some(5200)));
+        assert_eq!(day.quote.market_status.as_deref(), Some(MARKET_OPEN));
+    }
+
+    #[test]
+    fn any_other_market_status_hides_bid_and_offer() {
+        for status in ["pre_open", "break", "OPEN", ""] {
+            let day = parse_symbol_page("BBCA.JK", &bbca_with_status(status)).unwrap();
+            assert_eq!((day.quote.bid, day.quote.offer), (None, None), "{status:?}");
+        }
+    }
+
+    #[test]
+    fn index_keeps_decimals_in_the_series_and_rounds_the_quote() {
+        let day = parse_symbol_page("^JKSE.JK", &fixture("stockbit_symbol_ihsg.html")).unwrap();
+        let q = &day.quote;
+        assert_eq!(
+            (q.price, q.prev_close, q.change),
+            (5388, Some(5328), Some(60))
+        );
+        // An index has no book even while open.
+        assert_eq!((q.bid, q.offer), (None, None));
+        assert_eq!(day.points.last().unwrap().price, 5387.90);
+    }
+
+    #[test]
+    fn suspended_and_delisted_stocks_are_empty_sessions_not_errors() {
+        for (file, note) in [
+            (
+                "stockbit_symbol_maba.html",
+                "Stockbit lists the stock as suspended",
+            ),
+            (
+                "stockbit_symbol_myrx.html",
+                "Stockbit lists the stock as delisted",
+            ),
+        ] {
+            let day = parse_symbol_page("X.JK", &fixture(file)).unwrap();
+            assert!(day.points.is_empty(), "{file}");
+            assert_eq!(day.quote.session_note.as_deref(), Some(note), "{file}");
+            // The page's date/time is not a trade time when nothing traded.
+            assert_eq!(day.quote.as_of, None, "{file}");
+        }
+    }
+
+    /// HOME and BIMA on 2026-10-22: active, a flat chart at the previous
+    /// close, volume 0. Without a note they read as a traded flat session.
+    #[test]
+    fn an_untraded_active_stock_says_so_even_with_a_flat_chart() {
+        let page = fixture("stockbit_symbol_bbca.html");
+        assert!(page.contains(r#""volume":"286928500""#));
+        let page = page.replace(r#""volume":"286928500""#, r#""volume":"0""#);
+        let day = parse_symbol_page("BBCA.JK", &page).unwrap();
+        assert!(!day.points.is_empty());
+        assert_eq!(
+            day.quote.session_note.as_deref(),
+            Some("no trades this session")
+        );
+        assert_eq!(day.quote.as_of, None);
+    }
+
+    #[test]
+    fn unknown_code_is_symbol_not_found() {
+        let err = parse_symbol_page("ZZZZ.JK", &fixture("stockbit_symbol_zzzz_404.html"));
+        assert!(matches!(err, Err(IdxError::SymbolNotFound(s)) if s == "ZZZZ.JK"));
+    }
+
+    #[test]
+    fn a_page_without_next_data_is_a_layout_change() {
+        let err = parse_symbol_page("BBCA.JK", &fixture("stockbit_blocked_403.html"));
+        assert!(matches!(err, Err(IdxError::ParseError(_))), "{err:?}");
+    }
+
+    #[test]
+    fn http_403_is_upstream_blocked_and_404_is_not_found() {
+        assert!(matches!(
+            status_error(403, "BBCA.JK"),
+            IdxError::UpstreamBlocked(_)
+        ));
+        assert!(
+            matches!(status_error(404, "BBCA.JK"), IdxError::SymbolNotFound(s) if s == "BBCA.JK")
+        );
+        assert!(matches!(
+            status_error(429, "BBCA.JK"),
+            IdxError::RateLimited
+        ));
+        assert!(matches!(status_error(502, "BBCA.JK"), IdxError::Http(_)));
+    }
+
+    #[test]
+    fn codes_map_idx_symbols_and_index_tickers() {
+        assert_eq!(stockbit_code("BBCA.JK").unwrap(), "BBCA");
+        assert_eq!(stockbit_code("^JKSE.JK").unwrap(), "IHSG");
+        assert_eq!(stockbit_code("^JKLQ45.JK").unwrap(), "LQ45");
+        for other in ["AAPL.US", "^GSPC.JK", "BRK-B.JK", ".JK"] {
+            assert!(
+                matches!(stockbit_code(other), Err(IdxError::Unsupported(_))),
+                "{other}"
+            );
+        }
+    }
+}

crates/idx-core/src/api/types.rs

@@ -57,6 +57,41 @@ pub struct Quote {
     /// quote is returned, not when it is cached.
     #[serde(default)]
     pub behind_session: bool,
+    /// Best bid in IDR (whole Rupiah). Stockbit only, and only while its
+    /// market status is `open`: outside trading it is the closing book, not
+    /// a live one. Absent from JSON when unknown.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub bid: Option<i64>,
+    /// Best offer in IDR (whole Rupiah), gated like `bid`.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub offer: Option<i64>,
+    /// The provider's own session state, verbatim (Stockbit
+    /// `market_hour.status`, e.g. `close`). Absent for providers without one.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub market_status: Option<String>,
+    /// What the provider says about this symbol's session: suspended,
+    /// delisted, or no trades. Never inferred.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub session_note: Option<String>,
+}
+
+/// One price of today's session, minute by minute (Stockbit's chart).
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct IntradayPoint {
+    /// The minute, in WIB.
+    pub time: DateTime<FixedOffset>,
+    /// Last price at that minute in IDR; indices carry two decimals.
+    pub price: f64,
+}
+
+/// The latest session of one IDX symbol: its quote and the price per minute.
+/// Stockbit's public page carries no per-minute OHLC or volume.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Intraday {
+    pub quote: Quote,
+    /// Oldest first; empty when the symbol did not trade (suspended,
+    /// delisted, or no session yet), never an error.
+    pub points: Vec<IntradayPoint>,
 }
 
 /// OHLC candle data normalized from Yahoo Finance chart indicators.

crates/idx-core/src/api/yahoo/map.rs

@@ -65,6 +65,10 @@ pub(super) fn parse_quote(symbol: &str, chart: &ChartResponse) -> Result<Quote,
             .and_then(|ts| chrono::DateTime::from_timestamp(ts, 0))
             .map(|t| t.with_timezone(&crate::api::idx_offset())),
         behind_session: false,
+        bid: None,
+        offer: None,
+        market_status: None,
+        session_note: None,
     })
 }