Enum Error 

pub enum Error {
    Unauthorized(ErrorBody),
    NotFound(ErrorBody),
    RateLimited {
        retry_after: Option<Duration>,
        body: ErrorBody,
    },
    Http {
        status: StatusCode,
        retry_after: Option<Duration>,
        body: ErrorBody,
    },
    Transport(Error),
    WebSocket(WebSocketError),
    Codec {
        context: String,
        reason: String,
    },
    InvalidPreference {
        field: &'static str,
        reason: String,
    },
    OrderIdUnrecoverable(String),
    OrderResponseNotRepresentable {
        reason: String,
    },
    TokenProvider {
        source: Box<dyn Error + Send + Sync>,
    },
    InsecureBaseUrl {
        url: String,
        reason: String,
    },
}

Error returned by every fallible operation in this crate.

Variants

Unauthorized(ErrorBody)

HTTP 401. Distinct from Error::Http so a future token-refresh seam in SchwabClient has a single arm to hook.

NotFound(ErrorBody)

HTTP 404. Distinct from Error::Http because callers idiomatically map “broker says no such resource” to Ok(None).

RateLimited

429 with optional Retry-After.

Fields

retry_after: Option<Duration>

Parsed Retry-After header value, if Schwab sent one.

body: ErrorBody

Decoded response body.

Http

Any other non-2xx response. The status is authoritative; the body is supplementary. retry_after carries the parsed Retry-After header when the server sent one (the spec allows it on any 4xx / 5xx, not only 429); callers can read it via Error::retry_after without matching on the variant.

Fields

status: StatusCode

HTTP status from the response.

retry_after: Option<Duration>

Parsed Retry-After header value, if the server sent one.

body: ErrorBody

Decoded response body.

Transport(Error)

reqwest transport failure (DNS, connect, TLS, body read).

WebSocket(WebSocketError)

Streamer websocket: connect, handshake, or runtime frame error.

Codec

JSON serde failure on a wire body or streamer frame. context names the operation (e.g. "decode CHART_EQUITY frame", "encode subscribe request").

Fields

context: String

Names the operation that failed (e.g. "decode response body").

reason: String

Underlying serde error message.

InvalidPreference

/userPreference response missing a required field or carrying an unparseable value.

Fields

field: &'static str

Name of the missing or unparseable field.

reason: String

Why the field was rejected (e.g. "missing", parse error text).

OrderIdUnrecoverable(String)

Schwab acked a place / replace order but the Location header was absent or malformed, so the new order’s id is unrecoverable.

OrderResponseNotRepresentable

An crate::orders::Order returned by a read endpoint could not be converted into an crate::orders::OrderRequest for a follow-up place or replace call. The carried reason names the specific shape mismatch (e.g. a leg missing its instrument, an instrument missing its symbol, an unknown assetType). This variant is not retryable: the response will not change on a retry.

Fields

reason: String

What in the response prevented the conversion.

TokenProvider

A crate::TokenProvider failed to produce a bearer token, so no HTTP request could be issued. The wrapped source is the provider’s own error type, type-erased; the SDK has no opinion on whether it is transient.

Fields

source: Box<dyn Error + Send + Sync>

Underlying provider error, type-erased.

InsecureBaseUrl

A base URL passed to crate::SchwabClient::with_trader_base_url or crate::SchwabClient::with_market_data_base_url used a scheme that is not permitted for the current build. Release builds require https://; debug builds additionally permit http:// so local fixture servers (wiremock and similar) can be wired up in tests.

Fields

url: String

The rejected URL string.

reason: String

Why the URL was rejected.

Implementations

impl Error

pub fn is_retryable(&self) -> bool

Schwab-specific retry classification. Returns true for transient failures (network, 5xx, 429) where the same request can be safely retried by the caller. Returns false for terminal failures (4xx other than 429, codec errors, preference / location errors).

schwab-sdk does not implement retry itself; this method exists so downstream consumers can utilize it in their own retry logic.

Examples

A minimal backoff loop honoring Self::retry_after when present. In real code a crate such as backon is preferable; this shows the seam.

use std::time::Duration;
use schwab_sdk::Result;

async fn with_retry<F, Fut, T>(mut op: F) -> Result<T>
where
    F: FnMut() -> Fut,
    Fut: std::future::Future<Output = Result<T>>,
{
    let mut attempts = 0;
    loop {
        match op().await {
            Ok(value) => return Ok(value),
            Err(err) if err.is_retryable() && attempts < 3 => {
                attempts += 1;
                let delay = err.retry_after().unwrap_or(Duration::from_millis(500));
                tokio::time::sleep(delay).await;
            }
            Err(err) => return Err(err),
        }
    }
}

let quotes = with_retry(|| client.market_data().quotes().list(["AAPL"]).send()).await?;

pub fn retry_after(&self) -> Option<Duration>

Retry-After duration parsed from a non-2xx response, when the server sent the header. None for variants that do not carry HTTP status (transport, codec, etc.) or when the header was absent. Surfaces on both Error::RateLimited (429) and Error::Http (any other 4xx / 5xx Schwab annotated with Retry-After, typically 503).

Trait Implementations

impl Debug for Error

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for Error

fn fmt(&self, __formatter: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Error for Error

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl From<Error> for Error

fn from(source: Error) -> Self

Converts to this type from the input type.

impl From<WebSocketError> for Error

fn from(source: WebSocketError) -> Self

Converts to this type from the input type.

impl From<WebSocketError> for Error

fn from(value: WebSocketError) -> Self

Converts to this type from the input type.