Struct Client 

pub struct Client { /* private fields */ }

Main client for interacting with IG Markets API

This client provides a unified interface for all IG Markets API operations, including market data, account management, and order execution.

Implementations

impl Client

pub fn try_new() -> Result<Self, AppError>

Creates a new client instance from the environment, without performing initial authentication, returning an error if the underlying HTTP client cannot be constructed.

This is the environment convenience path: the configuration comes from Config::default, which loads a local .env file and reads the IG_* environment namespace. Embedders that supply their own configuration should use Client::with_config instead, which touches neither.

Returns

• Ok(Client) - A client ready to use with the default configuration.
• Err(AppError) - If the underlying HTTP client cannot be constructed.

Errors

Returns AppError::Network if the underlying reqwest client cannot be built (e.g. the system TLS backend fails to initialize).

pub fn with_config(config: Config) -> Result<Self, AppError>

Creates a new client instance from a caller-supplied Config, without reading a .env file or the IG_* environment namespace.

This is the injection path for applications that own their configuration source (their own namespaced environment variables, a config file, a secrets manager) and must not have the crate reach for globals. Build the Config with Config::from_credentials, which is likewise env-free; Client::try_new remains the .env convenience path.

As with try_new, no authentication is performed here: session login and token refresh happen transparently on the first API call.

Two knobs live outside Config and are still resolved from the process environment on this path: the retry policy (MAX_RETRY_COUNT / RETRY_DELAY_SECS, read per request by RetryConfig::default) and IG_PRICING_ADAPTER (the Lightstreamer price adapter name). Neither carries a credential and both have safe defaults, so an embedder that sets neither is unaffected.

For streaming, pair this with StreamerClient::with_client: StreamerClient::new builds its own client via try_new and would go back to the .env / IG_* path.

use ig_client::prelude::*;

// Fail fast on a missing variable: an empty credential would only
// surface later as a confusing authentication failure.
fn required_var(name: &str) -> Result<String, AppError> {
    std::env::var(name).map_err(|_| AppError::InvalidInput(format!("{name} is not set")))
}

let credentials = Credentials::new(
    required_var("MYAPP_IG_USERNAME")?,
    required_var("MYAPP_IG_PASSWORD")?,
    required_var("MYAPP_IG_ACCOUNT_ID")?,
    required_var("MYAPP_IG_API_KEY")?,
);
let client = Client::with_config(Config::from_credentials(credentials))?;

Arguments

• config - The configuration the client and its session layer will use.

Returns

• Ok(Client) - A client ready to use with config.
• Err(AppError) - If the underlying HTTP client cannot be constructed.

Errors

Returns AppError::Network if the underlying reqwest client cannot be built (e.g. the system TLS backend fails to initialize).

pub fn config(&self) -> &Config

Returns the configuration this client was built with.

Useful to confirm which environment the client is pointed at (e.g. client.config().rest_api.base_url). Config’s Debug / Display redact credentials and the database URL, so rendering it that way is safe. Its Serialize impl does not redact — never serialize a Config into logs, telemetry or an error payload.

pub async fn switch_account( &self, account_id: &str, default_account: Option<bool>, ) -> Result<(), AppError>

Switches every subsequent request to a different trading account.

Delegates to HttpClient::switch_account. A service holding one client per IG login needs this to reach that login’s other accounts: on v3 the account is chosen per request through IG-ACCOUNT-ID, so switching costs no request and does not disturb the session or the key pool. On v2 the account lives in the session and IG is asked to change it.

It mutates client-wide state, so a caller serving several accounts concurrently must serialise the switch with the request that follows it.

Errors

Returns whatever HttpClient::switch_account reports: notably AppError::InvalidInput for default_account = true, or for a multi-key v2 pool where switching would cost one request per key.

pub async fn ws_info(&self) -> Result<WebsocketInfo, AppError>

Gets WebSocket connection information for Lightstreamer, reusing the cached session.

Delegates to HttpClient::ws_info, which returns the cached session when it is valid and only logs in when needed.

Returns

• Ok(WebsocketInfo) - Server endpoint, authentication tokens, and account ID for the current session.
• Err(AppError) - If session retrieval (login / refresh) fails.

Errors

Returns AppError when the session cannot be retrieved.

pub async fn get_ws_info(&self) -> WebsocketInfo

👎Deprecated:

use ws_info() which reuses the cached session and returns a typed error instead of a default-on-error WebsocketInfo

Gets WebSocket connection information for Lightstreamer

Returns

• WebsocketInfo containing server endpoint, authentication tokens, and account ID

Trait Implementations

impl AccountService for Client

fn get_accounts<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<AccountsResponse, AppError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Gets information about all user accounts

fn get_positions<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<PositionsResponse, AppError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Gets open positions

fn get_positions_w_filter<'life0, 'life1, 'async_trait>( &'life0 self, filter: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<PositionsResponse, AppError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Gets open positions base in filter

fn get_working_orders<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<WorkingOrdersResponse, AppError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Gets working orders

fn get_activity<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, from: &'life1 str, to: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<AccountActivityResponse, AppError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Gets account activity

fn get_activity_with_details<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, from: &'life1 str, to: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<AccountActivityResponse, AppError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Gets detailed account activity

fn get_transactions<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, from: &'life1 str, to: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<TransactionHistoryResponse, AppError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Gets transaction history for a given period, handling pagination automatically.

fn get_preferences<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<AccountPreferencesResponse, AppError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Gets account preferences

fn update_preferences<'life0, 'async_trait>( &'life0 self, trailing_stops_enabled: bool, ) -> Pin<Box<dyn Future<Output = Result<(), AppError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Updates account preferences

fn get_activity_by_period<'life0, 'async_trait>( &'life0 self, period_ms: u64, ) -> Pin<Box<dyn Future<Output = Result<AccountActivityResponse, AppError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Gets account activity for a specified period

impl CostsService for Client

fn get_indicative_costs_open<'life0, 'life1, 'async_trait>( &'life0 self, request: &'life1 OpenCostsRequest, ) -> Pin<Box<dyn Future<Output = Result<IndicativeCostsResponse, AppError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Returns indicative costs and charges for opening a position

fn get_indicative_costs_close<'life0, 'life1, 'async_trait>( &'life0 self, request: &'life1 CloseCostsRequest, ) -> Pin<Box<dyn Future<Output = Result<IndicativeCostsResponse, AppError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Returns indicative costs and charges for closing a position

fn get_indicative_costs_edit<'life0, 'life1, 'async_trait>( &'life0 self, request: &'life1 EditCostsRequest, ) -> Pin<Box<dyn Future<Output = Result<IndicativeCostsResponse, AppError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Returns indicative costs and charges for editing a position

fn get_costs_history<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, from: &'life1 str, to: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<CostsHistoryResponse, AppError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Returns historical costs and charges for a date range, handling pagination automatically (the full window is returned).

fn get_durable_medium<'life0, 'life1, 'async_trait>( &'life0 self, quote_reference: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<DurableMediumResponse, AppError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Returns a durable medium document for a quote reference

impl MarketService for Client

fn search_markets<'life0, 'life1, 'async_trait>( &'life0 self, search_term: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<MarketSearchResponse, AppError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Searches markets by search term

fn get_market_details<'life0, 'life1, 'async_trait>( &'life0 self, epic: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<MarketDetails, AppError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Gets details of a specific market by its EPIC

fn get_multiple_market_details<'life0, 'life1, 'async_trait>( &'life0 self, epics: &'life1 [String], ) -> Pin<Box<dyn Future<Output = Result<MultipleMarketDetailsResponse, AppError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Gets details of multiple markets by their EPICs in a single request

fn get_historical_prices<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, epic: &'life1 str, resolution: &'life2 str, from: &'life3 str, to: &'life4 str, ) -> Pin<Box<dyn Future<Output = Result<HistoricalPricesResponse, AppError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Gets historical prices for a market

fn get_historical_prices_by_date_range<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, epic: &'life1 str, resolution: &'life2 str, start_date: &'life3 str, end_date: &'life4 str, ) -> Pin<Box<dyn Future<Output = Result<HistoricalPricesResponse, AppError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Gets historical prices for a market using path parameters (API v2)

fn get_recent_prices<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, params: &'life1 RecentPricesRequest<'life2>, ) -> Pin<Box<dyn Future<Output = Result<HistoricalPricesResponse, AppError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Gets recent historical prices with custom parameters

fn get_historical_prices_by_count_v1<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, epic: &'life1 str, resolution: &'life2 str, num_points: u32, ) -> Pin<Box<dyn Future<Output = Result<HistoricalPricesResponse, AppError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Gets historical prices by number of data points (API v1)

fn get_historical_prices_by_count_v2<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, epic: &'life1 str, resolution: &'life2 str, num_points: u32, ) -> Pin<Box<dyn Future<Output = Result<HistoricalPricesResponse, AppError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Gets historical prices by number of data points (API v2)

fn get_market_navigation<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<MarketNavigationResponse, AppError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Gets the top-level market navigation nodes

fn get_market_navigation_node<'life0, 'life1, 'async_trait>( &'life0 self, node_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<MarketNavigationResponse, AppError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Gets the market navigation node with the specified ID

fn get_all_markets<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<MarketData>, AppError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Navigates through all levels of the market hierarchy and collects all MarketData

fn get_vec_db_entries<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<DBEntryResponse>, AppError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Gets all markets converted to database entries format

fn get_categories<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<CategoriesResponse, AppError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Gets all categories of instruments enabled for the IG account

fn get_category_instruments<'life0, 'life1, 'async_trait>( &'life0 self, category_id: &'life1 str, page_number: Option<u32>, page_size: Option<u32>, ) -> Pin<Box<dyn Future<Output = Result<CategoryInstrumentsResponse, AppError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Gets all instruments for a specific category

impl OperationsService for Client

fn get_client_apps<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<ApplicationDetailsResponse, AppError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns a list of client-owned applications

fn disable_client_app<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<StatusResponse, AppError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Disables the current application key

impl OrderService for Client

fn create_order<'life0, 'life1, 'async_trait>( &'life0 self, order: &'life1 CreateOrderRequest, ) -> Pin<Box<dyn Future<Output = Result<CreateOrderResponse, AppError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Creates a new order

fn get_order_confirmation<'life0, 'life1, 'async_trait>( &'life0 self, deal_reference: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<OrderConfirmationResponse, AppError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Gets the confirmation of an order

fn get_order_confirmation_w_retry<'life0, 'life1, 'async_trait>( &'life0 self, deal_reference: &'life1 str, retries: u64, delay_ms: u64, ) -> Pin<Box<dyn Future<Output = Result<OrderConfirmationResponse, AppError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Gets the confirmation of an order with retry logic

fn update_position<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, deal_id: &'life1 str, update: &'life2 UpdatePositionRequest, ) -> Pin<Box<dyn Future<Output = Result<UpdatePositionResponse, AppError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Updates an existing position

fn update_level_in_position<'life0, 'life1, 'async_trait>( &'life0 self, deal_id: &'life1 str, limit_level: Option<f64>, ) -> Pin<Box<dyn Future<Output = Result<UpdatePositionResponse, AppError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Asynchronously updates the limit level of a position in a specified deal.

fn close_position<'life0, 'life1, 'async_trait>( &'life0 self, close_request: &'life1 ClosePositionRequest, ) -> Pin<Box<dyn Future<Output = Result<ClosePositionResponse, AppError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Closes an existing position

fn create_working_order<'life0, 'life1, 'async_trait>( &'life0 self, order: &'life1 CreateWorkingOrderRequest, ) -> Pin<Box<dyn Future<Output = Result<CreateWorkingOrderResponse, AppError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Creates a new working order

fn delete_working_order<'life0, 'life1, 'async_trait>( &'life0 self, deal_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<(), AppError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Deletes a working order based on the provided deal ID.

fn get_position<'life0, 'life1, 'async_trait>( &'life0 self, deal_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<SinglePositionResponse, AppError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Gets a single position by deal ID

fn update_working_order<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, deal_id: &'life1 str, update: &'life2 UpdateWorkingOrderRequest, ) -> Pin<Box<dyn Future<Output = Result<CreateWorkingOrderResponse, AppError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Updates an existing working order

impl SentimentService for Client

fn get_client_sentiment<'life0, 'life1, 'async_trait>( &'life0 self, market_ids: &'life1 [String], ) -> Pin<Box<dyn Future<Output = Result<ClientSentimentResponse, AppError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Returns client sentiment for multiple markets

fn get_client_sentiment_by_market<'life0, 'life1, 'async_trait>( &'life0 self, market_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<MarketSentiment, AppError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Returns client sentiment for a single market

fn get_related_sentiment<'life0, 'life1, 'async_trait>( &'life0 self, market_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<ClientSentimentResponse, AppError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Returns client sentiment for related markets

impl WatchlistService for Client

fn get_watchlists<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<WatchlistsResponse, AppError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns all watchlists belonging to the active account

fn create_watchlist<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, name: &'life1 str, epics: Option<&'life2 [String]>, ) -> Pin<Box<dyn Future<Output = Result<CreateWatchlistResponse, AppError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Creates a new watchlist with the given name and optional initial instruments

fn get_watchlist<'life0, 'life1, 'async_trait>( &'life0 self, watchlist_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<WatchlistMarketsResponse, AppError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Returns the markets in a specific watchlist

fn delete_watchlist<'life0, 'life1, 'async_trait>( &'life0 self, watchlist_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<StatusResponse, AppError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Deletes a watchlist

fn add_to_watchlist<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, watchlist_id: &'life1 str, epic: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<StatusResponse, AppError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Adds an instrument to a watchlist

fn remove_from_watchlist<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, watchlist_id: &'life1 str, epic: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<StatusResponse, AppError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Removes an instrument from a watchlist