Error Handling & Retry

Retry logic and error handling with the Rust SDK

Overview

The Rust SDK provides:

• structured LimitlessError variants
• HTTP ApiError details with status, method, URL, and response payload
• reusable retry helpers via with_retry and RetryableClient
• optional logging hooks for retry visibility

Error types

All SDK methods return:

type Result<T> = std::result::Result<T, LimitlessError>;

LimitlessError

Variant	Description
LimitlessError::Api(ApiError)	Non-2xx HTTP response
LimitlessError::AuthenticationRequired { operation }	Missing API key or HMAC credentials
LimitlessError::InvalidInput(String)	Local validation failure before a request is sent
LimitlessError::Request(reqwest::Error)	Transport error such as timeout or connection failure
LimitlessError::Decode(serde_json::Error)	Failed to decode response JSON
LimitlessError::Base64(base64::DecodeError)	Invalid HMAC secret encoding
LimitlessError::Signing(String)	EIP-712 or HMAC signing issue
LimitlessError::WebSocket(String)	WebSocket error

Inspecting API errors

use limitless_exchange_rust_sdk::{Client, LimitlessError};

match client.portfolio.get_positions().await {
    Err(LimitlessError::Api(api)) => {
        eprintln!("status {}", api.status);
        eprintln!("message {}", api.message);
        eprintln!("method {}", api.method);
        eprintln!("url {}", api.url);
        eprintln!("payload {}", api.data);

        if api.is_auth_error() {
            eprintln!("credentials are invalid or missing required scope");
        }
    }
    Err(err) => eprintln!("other error: {}", err),
    Ok(_) => {}
}

Authentication-required errors

The SDK fails early for authenticated methods when no credentials are configured:

match client.portfolio.get_positions().await {
    Err(LimitlessError::AuthenticationRequired { operation }) => {
        eprintln!("missing auth for {}", operation);
    }
    _ => {}
}

Raw HTTP responses

Every API-backed service method has a *_with_raw sibling that returns Result<SdkResponse<T>>. Use it when you need the HTTP status, response headers (rate-limit metadata, request IDs, content-type), or the exact response bytes alongside the decoded value. The base method (without the suffix) is unchanged and still returns just the decoded value.

The raw variant still returns the same LimitlessError::Api(ApiError) on any response with status >= 400. It only exposes the raw response on success.

use limitless_exchange_rust_sdk::SdkResponse;

// Default: decoded value only.
let markets = client.markets.get_active_markets(None).await?;

// Opt in to the raw response.
let response: SdkResponse<_> = client
    .markets
    .get_active_markets_with_raw(None)
    .await?;

println!("HTTP {}", response.raw.status);
if let Some(remaining) = response
    .raw
    .headers
    .get("x-ratelimit-remaining")
    .and_then(|v| v.to_str().ok())
{
    println!("rate limit remaining: {remaining}");
}
println!("markets returned: {}", response.data.data.len());
// response.raw.body holds the original response bytes.

SdkResponse<T>

Field / method	Type	Description
data	T	The decoded response value, identical to what the base method returns.
raw	RawResponse	The underlying HTTP response.
into_data()	T	Consume the wrapper and return just the decoded value.
map(f)	SdkResponse<U>	Transform data while preserving raw.

RawResponse

Field	Type	Description
status	u16	HTTP status code.
headers	HeaderMap	Response headers.
body	Vec<u8>	The original response body bytes.

The *_with_raw variant is available on every API-backed method (markets, portfolio, orders, AMM, API tokens, delegated orders, partner accounts, and market pages). WebSocket subscriptions are not affected.

with_retry

Use with_retry() to wrap any async operation:

use std::time::Duration;

use limitless_exchange_rust_sdk::{with_retry, RetryConfig};

let markets = client.markets.clone();

let value = with_retry(
    RetryConfig {
        max_retries: 5,
        exponential_base: 2.0,
        max_delay: Duration::from_secs(30),
        ..Default::default()
    },
    None,
    || {
        let markets = markets.clone();
        async move { markets.get_market("btc-above-100k-march-2025").await }
    },
)
.await?;

By default, retries are enabled for:

• 429
• 500
• 502
• 503
• 504
• connection failures
• timeouts

425 Too Early is not retried by default. If the API body has a trading-mode code, refresh maintenance status and do not retry the same blocked action. Otherwise, treat POST /orders failures as receive-window failures and rebuild a fresh signed order.

RetryableClient

Use RetryableClient when you want a retrying HTTP transport wrapper:

use std::sync::Arc;

use limitless_exchange_rust_sdk::{
    Client, ConsoleLogger, HmacCredentials, LogLevel, RetryConfig, RetryableClient,
};

let http = Client::builder()
    .hmac_credentials(HmacCredentials {
        token_id: std::env::var("LMTS_TOKEN_ID")?,
        secret: std::env::var("LMTS_TOKEN_SECRET")?,
    })
    .build()?;

let retryable = RetryableClient::new(
    http.clone(),
    RetryConfig::default(),
    Some(Arc::new(ConsoleLogger::new(LogLevel::Info))),
);

let raw_profile: serde_json::Value = retryable.get("/portfolio/positions").await?;
println!("{}", raw_profile);

You can still build the root Client from the same HttpClient:

let client = Client::from_http_client(http)?;

Retry callbacks

Attach a callback to observe retry attempts:

use std::time::Duration;

use limitless_exchange_rust_sdk::RetryConfig;

let config = RetryConfig::default().with_on_retry(|attempt, err, delay| {
    eprintln!(
        "retry attempt={} delay_ms={} error={}",
        attempt,
        delay.as_millis(),
        err
    );
});

Logging

Retry helpers accept an optional SharedLogger. Use ConsoleLogger during integration work:

use std::sync::Arc;

use limitless_exchange_rust_sdk::{ConsoleLogger, LogLevel};

let logger = Arc::new(ConsoleLogger::new(LogLevel::Debug));

For trading systems, treat InvalidInput and AuthenticationRequired as non-retryable. Retries are most useful for transient HTTP failures, rate limits, and network timeouts.