nautechsystems/nautilus_trader · error

option-chain reference price requests are not supported

Error message

option-chain reference price requests are not supported

What it means

The default DataClient implementation of request_option_chain_reference_price is a stub: it logs the request as not implemented and immediately returns an error. Clients that do not support option-chain reference price requests inherit this default and always fail with this message.

Source

Thrown at crates/common/src/clients/data.rs:627

    /// # Errors
    ///
    /// Returns an error if the trades request fails.
    fn request_funding_rates(&self, request: RequestFundingRates) -> anyhow::Result<()> {
        log_not_implemented(&request);
        Ok(())
    }

    /// Requests a reference price for an option-chain bootstrap.
    ///
    /// # Errors
    ///
    /// Returns an error if the option-chain reference price request fails.
    fn request_option_chain_reference_price(
        &self,
        request: RequestOptionChainReferencePrice,
    ) -> anyhow::Result<()> {
        log_not_implemented(&request);
        anyhow::bail!("option-chain reference price requests are not supported")
    }

    /// Requests historical or streaming bar data for a specified instrument and bar type.
    ///
    /// # Errors
    ///
    /// Returns an error if the bars request fails.
    fn request_bars(&self, request: RequestBars) -> anyhow::Result<()> {
        log_not_implemented(&request);
        Ok(())
    }

    /// Requests historical order book depth data for a specified instrument.
    ///
    /// # Errors
    ///
    /// Returns an error if the order book depths request fails.
    fn request_book_depth(&self, request: RequestBookDepth) -> anyhow::Result<()> {

View on GitHub (pinned to 18893faf8b)

Solutions

1. Use a data client implementation that overrides request_option_chain_reference_price with real support
2. Check the client's supported request types (or capability flags) before sending the request
3. Route the request to a venue/provider that supports option-chain reference prices
4. Implement the method in your custom DataClient subclass if you need the feature

// Only send the request if the client actually supports it (no default-stub).
// e.g. check the concrete client type or a capability flag before calling:
if !client.supports_option_chain_reference_price() { return Ok(()); }

// In Rust, detect the stub by testing the concrete type:
fn supports_ref_prices(c: &dyn DataClient) -> bool {
    // true only for client types that override request_option_chain_reference_price
    c.as_any().downcast_ref::<MySupportedClient>().is_some()
}

if let Err(e) = client.request_option_chain_reference_price(request) {
    if e.to_string().contains("not supported") {
        // fall back to another data source or skip this request type
    } else {
        return Err(e.into());
    }
}

When it happens

Trigger: Calling request_option_chain_reference_price (typically via a RequestOptionChainReferencePrice routed through the DataEngine) on a data client that has not overridden this method.

Common situations: Requesting option-chain reference prices against a broker/venue whose client adapter lacks support; wiring a generic data client for an options workflow it doesn't implement; code assuming all clients support every request type.

Related errors

• option_summary_family_subs mutex poisoned
• not yet implemented
• Invalid `OptionKind`, was '{invalid}'
• Unknown IB option right: {value}
• Invalid OPRA option symbol: {symbol_str}

AI-assisted analysis of nautechsystems/nautilus_trader@18893faf8b (2026-09-08). Data as JSON: /api/errors/47d1a4abfa2e6f21. Report an issue: GitHub.