Struct LseDataApiClient 

pub struct LseDataApiClient { /* private fields */ }

Authenticated client for the London Strategic Edge data API.

Wraps the internal transport shared with the vault, pointed at this host, and adds its endpoints: bond yields in bond_yield.

Request rationing is per client, not per call

Every request this client issues first passes a gate that bounds requests in flight to with_concurrency and spaces their starts by with_pace. That gate is shared by clones, so driving N concurrent fetches from one client (Arc it, or clone it) keeps the aggregate inside those two bounds rather than multiplying them by N. Two clients built separately by new share nothing and ration independently — one client per API key is the usable unit.

⚠️ Licensing

Data retrieved through this client is not redistributable. See the module documentation and https://londonstrategicedge.com/terms.

Implementations

impl LseDataApiClient

pub async fn fetch_bond_yield_stats( &self, ) -> Result<LseBondYieldStats, LseError>

Fetch the provider’s index of published bond-yield coverage.

Fetch this once and reuse the handle across queries — see LseBondYieldStats. It is the required first argument to fetch_bond_yields, which is what makes a query checkable against an endpoint that validates nothing itself.

Errors

See LseError.

pub async fn fetch_bond_yields( &self, stats: &LseBondYieldStats, query: &LseBondYieldQuery, ) -> Result<Vec<LseBondYieldRow>, LseError>

Fetch daily bond-yield observations for query.

stats is required, not optional, and query is validated against it before anything is sent. That is a deliberate API choice: the endpoint answers 200 with zero rows for an unknown country, an unknown tenor and an empty window alike, so a fetch that could skip validation would be a fetch that could silently return nothing. See the module documentation for the measurements.

Rows arrive ascending by date, oldest first, and the country code sent is the normalised one — a caller passing GB reaches the provider’s UK.

The whole answer arrives in one response

This endpoint is not paged: its envelope carries no cursor, and a request for the full published history of every United States tenor returned all 76,406 rows in a single 4-second response, matching /bond-yields/stats exactly. So this returns a Vec rather than a stream, and no pagination is invented for a surface that has none.

The envelope’s own count is checked against the rows delivered and a mismatch is an error rather than a short result — that is the signal a silent page cap would produce if the provider ever introduced one.

⚠️ An unnarrowed query is a large request

Omitting maturity fetches every tenor, which for a deep country over its full history is tens of thousands of rows against the client’s 30s total request timeout. Narrow the tenor or the window for anything latency-sensitive.

Errors

Anything validate raises, plus LseError’s transport and decode variants. A response whose count disagrees with the rows delivered is reported as LseError::Api carrying the 200 the provider actually sent.

impl LseDataApiClient

pub async fn fetch_economic_calendar_stats( &self, ) -> Result<LseCalendarStats, LseError>

Fetch the provider’s index of published economic-calendar coverage.

Fetch this once and reuse the handle across queries — see LseCalendarStats. It is the required first argument to fetch_economic_calendar, which is what makes a query checkable against an endpoint that validates nothing itself.

It is also how a caller detects the frozen feed reviving: latest has not moved past 2026-03-24 across measurements two months apart.

Errors

See LseError.

pub async fn fetch_economic_calendar( &self, stats: &LseCalendarStats, query: &LseCalendarQuery, ) -> Result<Vec<LseCalendarEvent>, LseError>

Fetch economic-calendar events for query.

stats is required, not optional, and query is validated against it before anything is sent. That is a deliberate API choice: the endpoint answers 200 with zero rows for an unknown country, an unknown impact rating, a reversed range and an empty window alike, so a fetch that could skip validation would be a fetch that could silently return nothing. See the module documentation for the measurements.

The country codes sent are the normalised ones — a caller passing GB reaches the provider’s UK — joined into a single comma-separated parameter.

🔴 Nothing is published after 2026-03-24

The feed is frozen. A window after that date is rejected by validation; a window spanning it returns only what exists up to it. This endpoint serves a historical archive, not a forward-looking calendar. See the module documentation.

🔴 An empty result is not necessarily an error

The provider publishes no per-country coverage, and coverage is very uneven — 88 of 108 countries hold fewer than 100 events, and UK holds 56, all in early 2026. A query for a published country inside the global range can legitimately return an empty Vec, and that is not reported as an error, because the library has no way to distinguish it from a quiet period. Only the three checks validation can actually make are made.

The whole answer arrives in one response

This endpoint is not paged: its envelope carries no cursor, the provider’s OpenAPI document declares no limit, offset, cursor or page parameter, and a request for the entire corpus with no country filter returned all 124,896 events in a single 29 MB response, matching total_events exactly. So this returns a Vec rather than a stream, and no pagination is invented for a surface that has none.

The envelope’s own count is checked against the events delivered and a mismatch is an error rather than a short result — that is the signal a silent page cap would produce if the provider ever introduced one.

⚠️ An unnarrowed query is a large request

That whole-corpus fetch took 6.3 seconds, against this client’s 30-second total request timeout. It is the measured worst case rather than a typical one, but the margin is not enormous: narrow the countries or the window for anything latency-sensitive.

Errors

Anything validate raises, plus LseError’s transport and decode variants. A response whose count disagrees with the events delivered is reported as LseError::Api carrying the 200 the provider actually sent.

impl LseDataApiClient

pub fn new(api_key: &str) -> Result<Self, LseError>

Create a client with an explicit API key.

Redirects are not followed

The key rides every request as a client-wide x-api-key default header, and reqwest’s cross-host header stripping covers Authorization, Cookie, Cookie2, Proxy-Authorization and WWW-Authenticate — not a custom header. Under reqwest’s default Policy::limited(10) a single server-issued 302 would therefore re-issue the request, live key attached, against whatever host this one named.

Policy::none makes the “this client only ever requests URLs it builds itself” invariant structural rather than a property of the provider’s current behaviour — a followed redirect is a server-supplied URL. An unexpected 3xx surfaces as a typed error instead of being followed, and it applies wholesale: a same-origin 301/308 (trailing-slash normalisation by a proxy or CDN) is surfaced too, so a base URL set via with_base_url must serve responses directly.

Errors

Returns LseError::InvalidCredential if the key cannot be encoded as an HTTP header value (e.g. non-ASCII bytes), or LseError::Http if the HTTP client cannot be built.

pub fn from_env() -> Result<Self, LseError>

Create a client from the LSE_API_KEY environment variable.

The same variable the vault client reads — one key authenticates both hosts.

Errors

Returns LseError::EnvVar if the variable is unset or does not hold valid UTF-8, plus anything new returns. Neither message ever contains the variable’s value.

pub fn with_base_url(self, base_url: impl Into<String>) -> Self

Override the data API base URL, for tests against a mock server or a proxy.

Infallible by design: this client only ever requests URLs it builds itself from this base — the endpoints here answer with a self-contained {count, data} envelope carrying no cursor, so there is never a server-supplied URL to follow and no trusted origin to derive.

pub fn with_client(self, client: Client) -> Self

Inject a pre-built reqwest::Client.

⚠️ The injected client must carry the x-api-key header itself

This replaces the authenticated client built by new, auth header included. It is intended for transport configuration (proxy, TLS, a shared connection pool) where the caller supplies credentials; a client without the header will see every request 401.

⚠️ It must also carry its own timeouts

new configures a 30s total timeout and a 30s read timeout; reqwest’s default is neither. Replacing the client drops both, and a timeout-less client interacts badly with the request gate: a permit is held for the whole request, so with the default concurrency of 2, two stalled connections exhaust the gate permanently — for this client and every clone of it, with no error, no log, and nothing to observe but a run that stops making progress. Set timeout and read_timeout on any client passed here.

⚠️ And its own redirect policy

new sets Policy::none so the API key cannot ride a server-issued redirect to another host; reqwest’s default is Policy::limited(10), which strips only the standard auth headers and would forward a custom x-api-key intact. A client supplied here that carries the key must set Policy::none itself, or a single 302 leaks the credential with no error and no log.

pub fn with_pace(self, pace: Duration) -> Self

Override the minimum delay between the starts of two requests.

Applies to every request this client issues, and is enforced against the gate this client shares with its clones — so N concurrent fetches still start one request per pace between them.

Pass Duration::ZERO to disable pacing entirely, at which point staying within the provider’s allowance becomes the caller’s responsibility. The default is derived from the allowance the vault documents; this host publishes no rate of its own, so the vault’s figure is used rather than an unrationed default.

pub fn with_concurrency(self, concurrency: usize) -> Self

Override how many requests this client may have in flight at once.

0 is clamped to 1, since a client that can never issue a request is never what was meant.

⚠️ Call this before cloning

This installs a fresh gate. Clones taken before the call keep the old one and ration separately from this client, which defeats the point of sharing; clones taken after share the new gate as usual.

Trait Implementations

impl Clone for LseDataApiClient

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for LseDataApiClient

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

Formats the value using the given formatter.