Bloomberg Data API

xbbg.blp

High-level Bloomberg data API: reference, historical, intraday.

This module provides the xbbg-compatible API using the Rust backend, with support for multiple DataFrame backends via narwhals.

API Design:

Async-first: Core implementation uses async/await (abdp, abdh, etc.)
Sync wrappers: Convenience functions wrap async with asyncio.run(), with a notebook bridge for one-shot requests
Generic API: arequest() and request() for power users and arbitrary Bloomberg requests
Users can use either style based on their needs

Engine Objects

class Engine()

Non-global Bloomberg engine for multi-source routing.

Use as a context manager to scope all blp.* calls to this engine:

engine = blp.Engine(host="bpipe.firm.com", auth_method="app", app_name="myapp")
with engine:
    df = blp.bdp(...)  # uses this engine, not the global

Or pass directly to individual calls:

df = blp.bdp(..., engine=engine)

The global configure() + blp.bdp() API is unaffected.

RequestEnvironment Objects

@dataclass(frozen=True, slots=True)
class RequestEnvironment()

Read-only engine and auth snapshot available to request middleware.

RequestContext Objects

@dataclass(slots=True)
class RequestContext()

Mutable context object passed through the request middleware chain.

add_middleware

def add_middleware(middleware: RequestMiddleware) -> RequestMiddleware

Middleware is called as middleware(context, call_next) and may be sync or async. Returning the middleware makes this usable as a decorator.

remove_middleware

def remove_middleware(middleware: RequestMiddleware) -> None

Remove a previously registered middleware callable.

clear_middleware

def clear_middleware() -> None

Remove all registered middleware.

get_middleware

def get_middleware() -> tuple[RequestMiddleware, ...]

Return the currently registered middleware chain.

set_middleware

def set_middleware(middleware: Sequence[RequestMiddleware]) -> None

Replace the current middleware chain.

shutdown

def shutdown() -> None

Signal the Bloomberg engine to shutdown.

Signals all worker threads to stop. They will terminate when they finish their current work or see the shutdown signal.

This is called automatically during Python interpreter shutdown. You usually don’t need to call this directly.

Example::

import xbbg

df = xbbg.bdp(“AAPL US Equity”, “PX_LAST”)

Explicit shutdown (optional - happens automatically on exit)

xbbg.shutdown()

reset

def reset() -> None

Reset the engine to allow reconfiguration.

Shuts down the current engine (if any) and clears configuration. The next Bloomberg request will create a fresh engine.

Example::

import xbbg

Initial usage

df = xbbg.bdp(“AAPL US Equity”, “PX_LAST”)

Need different config? Reset first

xbbg.reset() xbbg.configure(port=9999) df = xbbg.bdp(“AAPL US Equity”, “PX_LAST”) # Uses new config

is_connected

def is_connected() -> bool

Check if Bloomberg is connected and healthy.

Returns True if the engine exists and at least one worker has a live Bloomberg session. Returns False if the engine hasn’t been created yet or all workers have lost their connection.

Example::

import xbbg

print(xbbg.is_connected()) # False - not initialized yet

df = xbbg.bdp(“AAPL US Equity”, “PX_LAST”)

print(xbbg.is_connected()) # True - connected

configure

def configure(config=None, **kwargs) -> None

Configure the xbbg engine before first use.

This function must be called before any Bloomberg request is made. If called after the engine has started, the existing engine is shut down and will restart with the new config on next use.

Can be called with an EngineConfig object, keyword arguments, or both (kwargs override config fields). All defaults come from Rust.

See EngineConfig() for available fields and their defaults::

from xbbg import EngineConfig EngineConfig() EngineConfig(host=‘localhost’, port=8194, request_pool_size=2, subscription_pool_size=1, …)

Arguments:

config - An EngineConfig object with all settings.
**kwargs - Override individual fields (host, port, request_pool_size, subscription_pool_size, field_cache_path, auth_method, app_name, user_id, ip_address, token, etc.).

Raises:

TypeError - If an unknown keyword argument is passed.
ValueError - If num_start_attempts is less than 1.
RuntimeWarning - If called after the engine has already started (the existing engine is shut down and will restart with the new config).

Example::

import xbbg

Option 1: Using keyword arguments (most common)
Section titled “Option 1: Using keyword arguments (most common)”

xbbg.configure(request_pool_size=4, subscription_pool_size=2)

Option 2: Using EngineConfig object
Section titled “Option 2: Using EngineConfig object”

from xbbg import EngineConfig

xbbg.configure(EngineConfig(request_pool_size=4))

Option 3: EngineConfig + overrides
Section titled “Option 3: EngineConfig + overrides”

cfg = EngineConfig(request_pool_size=4) xbbg.configure(cfg, subscription_pool_size=2)

Option 4: B-PIPE / SAPI authentication
Section titled “Option 4: B-PIPE / SAPI authentication”

xbbg.configure( host=“bpipe-host”, port=8195, auth_method=“manual”, app_name=“my-app”, user_id=“123456”, ip_address=“10.0.0.1”, num_start_attempts=5, auto_restart_on_disconnection=False, )

Option 5: Custom field cache location
Section titled “Option 5: Custom field cache location”

xbbg.configure(field_cache_path=“/data/bloomberg/field_cache.json”)

set_backend

def set_backend(backend: Backend | str | None) -> None

Set the default DataFrame backend for all xbbg functions.

Arguments:

backend - The backend to use. Can be a Backend enum or string:
- Backend.NATIVE / “native”: Return xbbg native Arrow carrier object
- Backend.PYARROW / “pyarrow”: Return pyarrow Table
- Backend.NARWHALS / “narwhals”: Return narwhals DataFrame
- Backend.NARWHALS_LAZY / “narwhals_lazy”: Return narwhals LazyFrame
- Backend.PANDAS / “pandas”: Return pandas DataFrame
- Backend.POLARS / “polars”: Return polars DataFrame
- Backend.POLARS_LAZY / “polars_lazy”: Return polars LazyFrame
- Backend.DUCKDB / “duckdb”: Return DuckDB relation (lazy)
- None: Auto-select the first available default backend
Example::

import xbbg from xbbg import Backend

xbbg.set_backend(Backend.POLARS) df = xbbg.bdh(“AAPL US Equity”, “PX_LAST”) # Returns polars.DataFrame

Use lazy evaluation for deferred computation
Section titled “Use lazy evaluation for deferred computation”

xbbg.set_backend(Backend.POLARS_LAZY) lf = xbbg.bdh(“AAPL US Equity”, “PX_LAST”) # Returns polars.LazyFrame df = lf.collect() # Materialize when ready

String also works
Section titled “String also works”

xbbg.set_backend(“pandas”)

get_backend

def get_backend() -> Backend | None

Get the current default DataFrame backend.

arequest

async def arequest(
        service: str | Service,
        operation: str | Operation,
        *,
        request_operation: str | Operation | None = None,
        securities: str | Sequence[str] | None = None,
        security: str | None = None,
        fields: str | Sequence[str] | None = None,
        overrides: dict[str, Any] | Sequence[tuple[str, str]] | None = None,
        elements: Sequence[tuple[str, Any]] | None = None,
        start_date: DateLike = None,
        end_date: DateLike = None,
        start_datetime: DateLike = None,
        end_datetime: DateLike = None,
        event_type: str | None = None,
        event_types: Sequence[str] | None = None,
        interval: int | None = None,
        options: dict[str, Any] | Sequence[tuple[str, str]] | None = None,
        field_types: dict[str, str] | None = None,
        output: OutputMode | str = OutputMode.ARROW,
        extractor: ExtractorHint | str | None = None,
        format: Format | str | None = None,
        include_security_errors: bool = False,
        validate_fields: bool | None = None,
        backend: Backend | str | None = None,
        request_tz: str | None = None,
        output_tz: str | None = None,
        _raw: bool = False)

Async generic Bloomberg request.

This is the low-level API for power users who need to:

Send requests to arbitrary Bloomberg services
Use operations not covered by the typed convenience functions
Get raw JSON responses for debugging

For common use cases, prefer the typed functions: abdp, abdh, abds, abdib, abdtick.

Arguments:

service - Bloomberg service URI (e.g., Service.REFDATA or “//blp/refdata”).
operation - Request operation name (e.g., Operation.REFERENCE_DATA).
request_operation - Actual Bloomberg operation name when using Operation.RAW_REQUEST as the low-level escape hatch.
securities - List of security identifiers (for multi-security requests).
security - Single security identifier (for intraday requests).
fields - List of field names to retrieve.
overrides - Field overrides as dict or list of (name, value) tuples.
elements - Additional request elements as list of (name, value) tuples. Used for schema-driven parameters like intervalHasSeconds, periodicitySelection.
start_date - Start date for historical requests. Accepts ISO 8601 string, YYYYMMDD string, "today", datetime.date, datetime.datetime, or duck-typed pd.Timestamp.
end_date - End date for historical requests. Same accepted shapes as start_date.
start_datetime - Start datetime for intraday requests. Accepts ISO 8601 string (with or without tz), datetime.datetime (naive or tz-aware), or pd.Timestamp. Naive values use request_tz.
end_datetime - End datetime for intraday requests. Same accepted shapes as start_datetime.
request_tz - For intraday requests, how naive datetimes are interpreted before sending to Bloomberg (UTC, local, exchange, aliases, or IANA). Resolved and converted to UTC in the Rust engine.
output_tz - For intraday responses, relabel the time column to this zone (same instants; handled in the Rust engine).
event_type - Event type for intraday bars (TRADE, BID, ASK, etc.).
interval - Bar interval in minutes for intraday bars.
options - Additional Bloomberg options as dict or list of (key, value) tuples.
field_types - Manual type overrides for fields (for future type resolution).
output - Output format: OutputMode.ARROW (default) or OutputMode.JSON.
extractor - Override the auto-detected extractor. Use ExtractorHint.BULK for bulk data fields. If None, auto-detected from operation.
format - Output format hint for result structure.
include_security_errors - Include __SECURITY_ERROR__ rows for failed securities on ReferenceData requests.
validate_fields - Optional per-request override for field validation. True forces strict validation, False disables it, and None follows engine-level validation mode.
backend - DataFrame backend to return. If None, uses global default.

Returns:

DataFrame/Table in the requested format.

Example::

Query field metadata (//blp/apiflds service)

df = await arequest( Service.APIFLDS, Operation.FIELD_INFO, fields=[“PX_LAST”, “VOLUME”], )

Get raw JSON for debugging

json_table = await arequest( Service.REFDATA, Operation.REFERENCE_DATA, securities=[“AAPL US Equity”], fields=[“PX_LAST”], output=OutputMode.JSON, )

Custom Bloomberg request (power user)

df = await arequest( “//blp/refdata”, “ReferenceDataRequest”, securities=[“AAPL US Equity”], fields=[“PX_LAST”], )

Raw request marker with explicit Bloomberg operation

df = await arequest( Service.REFDATA, Operation.RAW_REQUEST, request_operation=Operation.REFERENCE_DATA, extractor=ExtractorHint.REFDATA, securities=[“AAPL US Equity”], fields=[“PX_LAST”], )

abdp

async def abdp(tickers: str | Sequence[str],
               flds: str | Sequence[str] | None = None,
               *,
               backend: Backend | str | None = None,
               format: Format | str | None = None,
               field_types: dict[str, str] | None = None,
               include_security_errors: bool = False,
               validate_fields: bool | None = None,
               **kwargs)

Async Bloomberg reference data (BDP).

Arguments:

tickers - Single ticker or list of tickers.
flds - Single field or list of fields to query.
backend - DataFrame backend to return. If None, uses global default. Supports lazy backends: ‘polars_lazy’, ‘narwhals_lazy’, ‘duckdb’.
format - Output format. Options:
- Format.LONG (default): ticker, field, value (strings)
- Format.LONG_TYPED: ticker, field, value_f64, value_i64, etc.
- Format.LONG_WITH_METADATA: ticker, field, value, dtype
field_types - Manual type overrides for fields (e.g., {‘VOLUME’: ‘int64’}). If None, types are auto-resolved from Bloomberg field metadata.
include_security_errors - Include __SECURITY_ERROR__ rows for securities that Bloomberg rejected.
validate_fields - Optional per-request override for field validation. True forces strict validation, False disables it, and None follows engine-level validation mode.
**kwargs - Bloomberg overrides and infrastructure options.

Returns:

DataFrame in long format with columns: ticker, field, value. For lazy backends, returns LazyFrame that must be collected.

Example::

Async usage

df = await abdp(“AAPL US Equity”, [“PX_LAST”, “VOLUME”])

Concurrent requests

dfs = await asyncio.gather( abdp(“AAPL US Equity”, “PX_LAST”), abdp(“MSFT US Equity”, “PX_LAST”), )

abdh

async def abdh(tickers: str | Sequence[str],
               flds: str | Sequence[str] | None = None,
               start_date: DateLike = None,
               end_date: DateLike = "today",
               *,
               backend: Backend | str | None = None,
               format: Format | str | None = None,
               field_types: dict[str, str] | None = None,
               validate_fields: bool | None = None,
               **kwargs)

Async Bloomberg historical data (BDH).

Arguments:

tickers - Single ticker or list of tickers.
flds - Single field or list of fields. Defaults to [‘PX_LAST’].
start_date - Start date. Defaults to 8 weeks before end_date.
end_date - End date. Defaults to ‘today’.
backend - DataFrame backend to return. If None, uses global default. Supports lazy backends: ‘polars_lazy’, ‘narwhals_lazy’, ‘duckdb’.
format - Output format. Options:
- Format.LONG (default): ticker, date, field, value (strings)
- Format.LONG_TYPED: ticker, date, field, value_f64, value_i64, etc.
- Format.LONG_WITH_METADATA: ticker, date, field, value, dtype
field_types - Manual type overrides for fields (e.g., {‘VOLUME’: ‘int64’}). If None, types are auto-resolved from Bloomberg field metadata.
validate_fields - Optional per-request override for field validation. True forces strict validation, False disables it, and None follows engine-level validation mode.
**kwargs - Additional overrides and infrastructure options.
adjust - Adjustment type (‘all’, ‘dvd’, ‘split’, ’-’, None).

Returns:

DataFrame in long format with columns: ticker, date, field, value. For lazy backends, returns LazyFrame that must be collected.

Example::

Async usage

df = await abdh(“AAPL US Equity”, “PX_LAST”, start_date=“2024-01-01”)

Concurrent requests

dfs = await asyncio.gather( abdh(“AAPL US Equity”, “PX_LAST”), abdh(“MSFT US Equity”, “PX_LAST”), )

abds

async def abds(tickers: str | Sequence[str],
               flds: str,
               *,
               backend: Backend | str | None = None,
               validate_fields: bool | None = None,
               **kwargs)

Async Bloomberg bulk data (BDS).

Arguments:

tickers - Single ticker or list of tickers.
flds - Single field name (bulk fields return multiple rows).
backend - DataFrame backend to return. If None, uses global default.
validate_fields - Optional per-request override for field validation. True forces strict validation, False disables it, and None follows engine-level validation mode.
**kwargs - Bloomberg overrides and infrastructure options.

Returns:

DataFrame with one row per Bloomberg bulk row. The only xbbg-added columns are ticker and field; bulk subfield columns preserve Bloomberg’s labels exactly as emitted, including spaces, punctuation, and case. Higher-level helpers must rename their own semantic outputs.

Example::

df = await abds(“AAPL US Equity”, “DVD_Hist_All”) df = await abds(“SPX Index”, “INDX_MEMBERS”, backend=“polars”)

abdib

async def abdib(ticker: str,
                dt: DateLike = None,
                session: str = "allday",
                typ: str = "TRADE",
                *,
                start_datetime: DateLike = None,
                end_datetime: DateLike = None,
                interval: int = 1,
                backend: Backend | str | None = None,
                request_tz: str | None = None,
                output_tz: str | None = None,
                **kwargs)

Async Bloomberg intraday bar data (BDIB).

Arguments:

ticker - Ticker name.
dt - Date to download (for single-day requests).
session - Trading session name. Ignored when start_datetime/end_datetime provided.
typ - Event type (TRADE, BID, ASK, etc.).
start_datetime - Explicit start datetime for multi-day requests.
end_datetime - Explicit end datetime for multi-day requests.
interval - Bar interval in minutes (default: 1), or seconds if intervalHasSeconds=True.
backend - DataFrame backend to return. If None, uses global default.
request_tz - How naive start_datetime / end_datetime (and full-day dt window) are interpreted before Bloomberg: UTC (default when omitted), local, exchange (uses this ticker), NY/LN/TK/HK, another ticker string, or an IANA zone. Conversion to UTC is done in the Rust engine.
output_tz - Relabel the time column to this zone (same instants; Rust engine).
**kwargs - Additional Bloomberg options (e.g., intervalHasSeconds, gapFillInitialBar, or 0.x request-element aliases such as Points=1). Pass true Bloomberg field overrides via overrides={...}.

Returns:

DataFrame with intraday bar data.

Example::

1-minute bars (default)

df = await abdib(“AAPL US Equity”, dt=“2024-12-01”)

5-minute bars with explicit datetime range

df = await abdib( “AAPL US Equity”, start_datetime=“2024-12-01 09:30”, end_datetime=“2024-12-01 16:00”, interval=5, )

10-second bars

df = await abdib(“AAPL US Equity”, dt=“2024-12-01”, interval=10, intervalHasSeconds=True)

abdtick

async def abdtick(ticker: str,
                  start_datetime: DateLike,
                  end_datetime: DateLike,
                  *,
                  event_types: Sequence[str] | None = None,
                  backend: Backend | str | None = None,
                  request_tz: str | None = None,
                  output_tz: str | None = None,
                  **kwargs)

Async Bloomberg tick data (BDTICK).

Arguments:

ticker - Ticker name.
start_datetime - Start datetime.
end_datetime - End datetime.
event_types - Event types to retrieve. Defaults to [“TRADE”].
Options - TRADE, BID, ASK, BID_BEST, ASK_BEST, MID_PRICE, AT_TRADE, BEST_BID, BEST_ASK.
backend - DataFrame backend to return. If None, uses global default.
request_tz - How naive datetimes are interpreted before Bloomberg (see abdib).
output_tz - Relabel time column (same instants; Rust engine).
**kwargs - Additional Bloomberg options. Schema-recognized request elements and 0.x request-element aliases such as Points=1 may be passed as individual keyword arguments. Pass true Bloomberg field overrides via overrides={...}.

Returns:

DataFrame with tick data.

Example::

df = await abdtick(“AAPL US Equity”, “2024-12-01 09:30”, “2024-12-01 10:00”) df = await abdtick( “AAPL US Equity”, “2024-12-01 09:30”, “2024-12-01 10:00”, event_types=[“TRADE”, “BID”, “ASK”] ) df = await abdtick(“AAPL US Equity”, “2024-12-01 09:30”, “2024-12-01 10:00”, backend=“polars”)

Tick Objects

@dataclass
class Tick()

Single tick data point from a subscription.

Attributes:

ticker - Security identifier
field - Bloomberg field name
value - Field value (float, int, str, bool, datetime, or None)
timestamp - Time the tick was received

Subscription Objects

class Subscription()

Subscription handle with async iteration and dynamic control.

Supports:

Async iteration: async for tick in sub
Dynamic add/remove: await sub.add(['MSFT US Equity'])
Context manager: async with xbbg.asubscribe(...) as sub:
Explicit unsubscribe: await sub.unsubscribe(drain=True)

Example::

sub = await xbbg.asubscribe([“AAPL US Equity”], [“LAST_PRICE”, “BID”])

async for batch in sub:

batch is xbbg.ArrowRecordBatch

print(batch.to_pylist())

if should_add_msft: await sub.add([“MSFT US Equity”])

await sub.unsubscribe()

init

def __init__(py_sub,
             raw: bool,
             backend: Backend | None,
             tick_mode: bool = False)

Initialize subscription wrapper.

Arguments:

py_sub - The underlying PySubscription from Rust
raw - If True, yield raw Arrow batches
backend - DataFrame backend for conversion (if not raw)
tick_mode - If True, convert batches to dicts (implies raw=True)

add

async def add(tickers: str | list[str]) -> None

Add tickers to subscription dynamically.

Arguments:

tickers - Single ticker or list of tickers to add

remove

async def remove(tickers: str | list[str]) -> None

Remove tickers from subscription dynamically.

Arguments:

tickers - Single ticker or list of tickers to remove

tickers

@property
def tickers() -> list[str]

Currently active tickers.

failed_tickers

@property
def failed_tickers() -> list[str]

Tickers Bloomberg rejected or terminated.

failures

@property
def failures() -> list[dict[str, str]]

Non-fatal per-ticker subscription failures.

Each entry contains: - ticker: Bloomberg topic string - reason: Bloomberg failure detail - kind: “failure” or “terminated”

topic_states

@property
def topic_states() -> dict[str, dict[str, int | str]]

Topic lifecycle state keyed by ticker/topic.

session_status

@property
def session_status() -> dict[str, int | str]

Session-level connection status for this subscription.

admin_status

@property
def admin_status() -> dict[str, int | bool | None]

Bloomberg admin/slow-consumer status for this subscription.

service_status

@property
def service_status() -> dict[str, dict[str, int | bool]]

Service availability status keyed by Bloomberg service name.

events

@property
def events() -> list[dict[str, str | int | None]]

Bounded lifecycle/event history for the subscription.

status

@property
def status() -> dict[str, Any]

Combined operational status snapshot.

fields

@property
def fields() -> list[str]

Subscribed fields.

is_active

@property
def is_active() -> bool

Whether the subscription is still active.

all_failed

@property
def all_failed() -> bool

Whether every requested ticker has ended in failure/termination.

stats

@property
def stats() -> dict

Subscription metrics.

Returns:

dict with keys:

messages_received: int - total messages received from Bloomberg
dropped_batches: int - batches dropped due to overflow
batches_sent: int - batches successfully sent to Python
slow_consumer: bool - True if DATALOSS was received
data_loss_events: int - total Bloomberg data-loss signals observed
last_message_us: int - latest receive timestamp seen from Bloomberg
last_data_loss_us: int - latest data-loss timestamp seen from Bloomberg
effective_overflow_policy: str - actual runtime policy used by the Rust stream

unsubscribe

async def unsubscribe(drain: bool = False) -> list[Any] | None

Close subscription and optionally drain remaining data.

Arguments:

drain - If True, return any remaining buffered batches

Returns:

List of remaining batches if drain=True, else None

asubscribe

async def asubscribe(tickers: str | list[str],
                     fields: str | list[str],
                     *,
                     raw: bool = False,
                     all_fields: bool = False,
                     backend: Backend | str | None = None,
                     service: str | None = None,
                     options: list[str] | None = None,
                     tick_mode: bool = False,
                     flush_threshold: int | None = None,
                     stream_capacity: int | None = None,
                     overflow_policy: str | None = None,
                     output: str | None = None) -> Subscription

Create an async subscription to real-time market data.

This is the low-level subscription API with full control over the subscription lifecycle, including dynamic add/remove.

Subscription recovery is handled automatically by the Bloomberg SDK (see BLPAPI ChangeLog v3.11.6); per-subscription availability transitions fire as SubscriptionStreamsActivated / SubscriptionStreamsDeactivated events which are reflected in sub.topic_states (streams_active).

Arguments:

tickers - Securities to subscribe to
fields - Fields to subscribe to (e.g., ‘LAST_PRICE’, ‘BID’, ‘ASK’)
raw - If True, yield raw Arrow RecordBatches for max performance
all_fields - If True, expose all top-level scalar Bloomberg subscription fields
backend - DataFrame backend for batch conversion (ignored if raw=True)
service - Bloomberg service (e.g., ‘//blp/mktdata’). If provided, uses subscribe_with_options
options - List of subscription options. If provided, uses subscribe_with_options
tick_mode - If True, return native dict ticks without building Arrow (implies raw=True)
flush_threshold - Batch flush threshold (validation only in Wave 1)
stream_capacity - Stream channel capacity (validation only in Wave 1)
overflow_policy - Overflow policy for stream (validation only in Wave 1)

Returns:

Subscription handle for iteration and control

Example::

Basic usage

sub = await xbbg.asubscribe([“AAPL US Equity”], [“LAST_PRICE”, “BID”]) async for batch in sub: print(batch) await sub.unsubscribe()

With context manager

async with xbbg.asubscribe([“AAPL US Equity”], [“LAST_PRICE”]) as sub: count = 0 async for batch in sub: print(batch) count += 1 if count >= 10: break

Dynamic add/remove

sub = await xbbg.asubscribe([“AAPL US Equity”], [“LAST_PRICE”]) async for batch in sub: if should_add_msft: await sub.add([“MSFT US Equity”]) if should_remove_aapl: await sub.remove([“AAPL US Equity”])

Tick mode (dict conversion)

sub = await xbbg.asubscribe([“AAPL US Equity”], [“LAST_PRICE”], tick_mode=True) async for tick_dict in sub: print(tick_dict) # {‘ticker’: ‘AAPL US Equity’, ‘LAST_PRICE’: 150.25, …}

astream

async def astream(tickers: str | list[str],
                  fields: str | list[str],
                  *,
                  raw: bool = False,
                  all_fields: bool = False,
                  backend: Backend | str | None = None,
                  callback: Callable[[Any], None] | None = None,
                  tick_mode: bool = False,
                  flush_threshold: int | None = None,
                  stream_capacity: int | None = None,
                  overflow_policy: str | None = None)

High-level async streaming - simple iteration.

This is the simple API for streaming data. For dynamic add/remove, use asubscribe() instead.

Arguments:

tickers - Securities to subscribe to
fields - Fields to subscribe to
raw - If True, yield raw Arrow RecordBatches
all_fields - If True, expose all top-level scalar Bloomberg subscription fields
backend - DataFrame backend for batch conversion
callback - Optional callback function to invoke on each batch
tick_mode - If True, convert batches to dicts

Yields:

Batches of market data (RecordBatch, DataFrame, or dict)

Example::

async for batch in xbbg.astream([“AAPL US Equity”], [“LAST_PRICE”]): print(batch) if done: break

With callback

def on_batch(batch): print(f”Got batch: {batch}”)

async for _ in xbbg.astream([“AAPL US Equity”], [“LAST_PRICE”], callback=on_batch): pass

stream

def stream(tickers: str | list[str],
           fields: str | list[str],
           *,
           raw: bool = False,
           all_fields: bool = False,
           backend: Backend | str | None = None,
           callback: Callable[[Any], None] | None = None,
           tick_mode: bool = False,
           flush_threshold: int | None = None,
           stream_capacity: int | None = None,
           overflow_policy: str | None = None)

High-level sync streaming using a background thread.

Note: This is a generator that runs the async stream in a background thread. Use astream() for async contexts.

Arguments:

tickers - Securities to subscribe to
fields - Fields to subscribe to
raw - If True, yield raw Arrow RecordBatches
all_fields - If True, expose all top-level scalar Bloomberg subscription fields
backend - DataFrame backend for batch conversion
callback - Optional callback function to invoke on each batch
tick_mode - If True, convert batches to dicts

Yields:

Batches of market data

Example::

for batch in xbbg.stream([“AAPL US Equity”], [“LAST_PRICE”]): print(batch) if done: break

avwap

async def avwap(tickers: str | list[str],
                fields: str | list[str] | None = None,
                *,
                start_time: str | None = None,
                end_time: str | None = None,
                raw: bool = False,
                all_fields: bool = False,
                backend: Backend | str | None = None) -> Subscription

Subscribe to real-time VWAP data (//blp/mktvwap).

Provides streaming Volume Weighted Average Price calculations.

Arguments:

tickers - Securities to subscribe to
fields - Fields to subscribe to (default: RT_PX_VWAP, RT_VWAP_VOLUME)
start_time - VWAP calculation start time (e.g., “09:30”)
end_time - VWAP calculation end time (e.g., “16:00”)
raw - If True, yield raw Arrow RecordBatches for max performance
all_fields - If True, expose all top-level scalar Bloomberg subscription fields
backend - DataFrame backend for batch conversion (ignored if raw=True)

Returns:

Subscription handle for iteration and control

Example::

sub = await xbbg.avwap([“AAPL US Equity”]) async for batch in sub: print(batch) await sub.unsubscribe()

With custom time window

sub = await xbbg.avwap([“AAPL US Equity”, “MSFT US Equity”], start_time=“09:30”, end_time=“16:00”)

With specific fields

sub = await xbbg.avwap(“AAPL US Equity”, [“RT_PX_VWAP”, “RT_VWAP_VOLUME”, “RT_VWAP_TURNOVER”])

amktbar

async def amktbar(tickers: str | list[str],
                  *,
                  interval: int = 1,
                  start_time: str | None = None,
                  end_time: str | None = None,
                  raw: bool = False,
                  all_fields: bool = False,
                  backend: Backend | str | None = None) -> Subscription

Subscribe to real-time streaming OHLC bars.

Like bdib but streaming instead of historical. Provides real-time bar updates as they form during the trading day.

Arguments:

tickers - Security identifier(s).
interval - Bar interval in minutes (default: 1).
start_time - Optional start time in HH:MM format.
end_time - Optional end time in HH:MM format.
raw - If True, return raw xbbg ArrowRecordBatch (default: False).
all_fields - If True, expose all top-level scalar Bloomberg subscription fields
backend - DataFrame backend to return. If None, uses global default.

Returns:

Subscription object for async iteration.

Example::

async with await amktbar(“AAPL US Equity”, interval=5) as sub: async for batch in sub: print(batch)

Multiple securities

sub = await amktbar([“AAPL US Equity”, “MSFT US Equity”], interval=1) async for batch in sub: print(batch)

adepth

async def adepth(tickers: str | list[str],
                 *,
                 raw: bool = False,
                 all_fields: bool = False,
                 backend: Backend | str | None = None) -> Subscription

Subscribe to Level 2 market depth / order book data.

.. warning:: Requires Bloomberg B-PIPE license. This feature is not available with standard Terminal connections.

Provides real-time order book updates with bid/ask prices and sizes at multiple levels.

Arguments:

tickers - Security identifier(s).
raw - If True, return raw xbbg ArrowRecordBatch (default: False).
all_fields - If True, expose all top-level scalar Bloomberg subscription fields
backend - DataFrame backend to return. If None, uses global default.

Returns:

Subscription object for async iteration.

Raises:

BlpBPipeError - If B-PIPE license is not available.

Example::

Subscribe to market depth
Section titled “Subscribe to market depth”

async with await adepth(“AAPL US Equity”) as sub: async for batch in sub: print(batch) # Order book updates

achains

async def achains(underlying: str,
                  *,
                  chain_type: str = "OPTIONS",
                  raw: bool = False,
                  all_fields: bool = False,
                  backend: Backend | str | None = None) -> Subscription

Subscribe to option or futures chain updates.

.. warning:: Requires Bloomberg B-PIPE license. This feature is not available with standard Terminal connections.

Provides real-time updates for option chains or futures chains on a given underlying security.

Arguments:

underlying - Underlying security identifier.
chain_type - Type of chain - “OPTIONS” or “FUTURES” (default: “OPTIONS”).
raw - If True, return raw xbbg ArrowRecordBatch (default: False).
all_fields - If True, expose all top-level scalar Bloomberg subscription fields
backend - DataFrame backend to return. If None, uses global default.

Returns:

Subscription object for async iteration.

Raises:

BlpBPipeError - If B-PIPE license is not available.

Example::

Subscribe to option chain
Section titled “Subscribe to option chain”

async with await achains(“AAPL US Equity”) as sub: async for batch in sub: print(batch) # Option chain updates

Subscribe to futures chain
Section titled “Subscribe to futures chain”

sub = await achains(“ES1 Index”, chain_type=“FUTURES”)

abta

async def abta(tickers: str | list[str],
               study: str,
               *,
               start_date: str | None = None,
               end_date: str | None = None,
               periodicity: str = "DAILY",
               interval: int | None = None,
               **study_params) -> DataFrameResult

Get technical analysis study data (async).

Uses Bloomberg //blp/tasvc service to calculate technical indicators.

Arguments:

tickers - Security or list of securities
study - Study type (e.g., ‘sma’, ‘rsi’, ‘macd’, ‘boll’, ‘atr’)
start_date - Start date. Accepts ISO 8601 / YYYYMMDD string, datetime.date, datetime.datetime, or pd.Timestamp.
end_date - End date. Same accepted shapes as start_date.
periodicity - Data periodicity (‘DAILY’, ‘WEEKLY’, ‘MONTHLY’, ‘INTRADAY’)
interval - Intraday interval in minutes (only for periodicity=‘INTRADAY’)
**study_params - Study-specific parameters (e.g., period=20 for SMA period)

Returns:

DataFrame with study results

Available Studies: Moving Averages: sma, ema, wma, vma, tma

Oscillators - rsi, macd, mao, momentum, roc
Bands - boll (Bollinger), keltner, mae
Trend - dmi/adx, stoch, trender, parabolic/sar
Volume - chko, ado, vat
Volatility - atr, hurst
Other - ichimoku, pivot, williams

Example::

Simple Moving Average with 20-day period
Section titled “Simple Moving Average with 20-day period”

df = await xbbg.abta(“AAPL US Equity”, “sma”, period=20)

RSI with 14-day period
Section titled “RSI with 14-day period”

df = await xbbg.abta(“AAPL US Equity”, “rsi”, period=14)

MACD with custom parameters
Section titled “MACD with custom parameters”

df = await xbbg.abta(“AAPL US Equity”, “macd”, maPeriod1=12, maPeriod2=26, sigPeriod=9)

Bollinger Bands with 20-day period and 2 std devs
Section titled “Bollinger Bands with 20-day period and 2 std devs”

df = await xbbg.abta(“AAPL US Equity”, “boll”, period=20, upperBand=2.0, lowerBand=2.0)

Intraday RSI with 60-minute bars
Section titled “Intraday RSI with 60-minute bars”

df = await xbbg.abta(“AAPL US Equity”, “rsi”, periodicity=“INTRADAY”, interval=60)

Multiple securities (sends concurrent requests)
Section titled “Multiple securities (sends concurrent requests)”

df = await xbbg.abta([“AAPL US Equity”, “MSFT US Equity”], “rsi”)

ta_studies

def ta_studies() -> list[str]

List available technical analysis study names.

Returns:

List of study short names that can be used with bta()/abta()

Example::

xbbg.ta_studies() [‘sma’, ‘ema’, ‘rsi’, ‘macd’, ‘boll’, ‘atr’, …]

ta_study_params

def ta_study_params(study: str) -> dict[str, Any]

Get default parameters for a technical analysis study.

Arguments:

study - Study name (e.g., ‘rsi’, ‘macd’, ‘boll’)

Returns:

Dictionary of parameter names and their default values

Example::

xbbg.ta_study_params(‘rsi’)

{'period' - 14, ‘priceSourceClose’: ‘PX_LAST’}

xbbg.ta_study_params(‘macd’)
{'maPeriod1' - 12, ‘maPeriod2’: 26, ‘sigPeriod’: 9, ‘priceSourceClose’: ‘PX_LAST’}

xbbg.ta_study_params(‘boll’)
{'period' - 20, ‘upperBand’: 2.0, ‘lowerBand’: 2.0, ‘priceSourceClose’: ‘PX_LAST’}

generate_ta_stubs

def generate_ta_stubs(output_dir: str | None = None) -> str

Generate Python type stubs for technical analysis studies.

Creates a .pyi file with TypedDict definitions for all TA study parameters. Stubs are generated from the //blp/tasvc schema for IDE autocomplete support.

Arguments:

output_dir - Output directory (default: ~/.xbbg/stubs/)

Returns:

Path to the generated stub file.

Example::

xbbg.generate_ta_stubs() ’~/.xbbg/stubs/ta_studies.pyi’

Then in your code, IDE will autocomplete:

from xbbg.stubs.ta_studies import RSIParams params: RSIParams = {‘period’: 14}

abql

async def abql(expression: str,
               *,
               backend: Backend | str | None = None) -> DataFrameResult

Async Bloomberg Query Language (BQL) request.

BQL is Bloomberg’s powerful query language for financial analytics. It allows you to query data across universes of securities with complex filters, calculations, and time series operations.

Arguments:

expression - BQL expression string.
backend - DataFrame backend to return. If None, uses global default.

Returns:

DataFrame with columns: id, , , … Where ‘id’ is the security identifier from the BQL universe.

Example::

Get price for a single security

df = await abql(“get(px_last) for(‘AAPL US Equity’)“)

Get multiple fields

df = await abql(“get(px_last, volume) for(‘AAPL US Equity’)“)

Holdings of an ETF

df = await abql(“get(id_isin, weights) for(holdings(‘SPY US Equity’))“)

Index members

df = await abql(“get(px_last) for(members(‘SPX Index’))“)

With filters

df = await abql(“get(px_last, pe_ratio) for(members(‘SPX Index’)) with(pe_ratio > 20)“)

Time series

df = await abql(“get(px_last) for(‘AAPL US Equity’) with(dates=range(-5d, 0d))”)

absrch

async def absrch(domain: str,
                 *,
                 backend: Backend | str | None = None,
                 **kwargs) -> DataFrameResult

Async Bloomberg Search (BSRCH) request.

BSRCH executes saved Bloomberg searches and returns matching securities.

Arguments:

domain - The saved search domain/name (e.g., “FI:SOVR”, “COMDTY:PRECIOUS”).
backend - DataFrame backend to return. If None, uses global default.
**kwargs - Additional search parameters passed as request elements.

Returns:

DataFrame with columns from the saved search results.

Example::

Sovereign bonds

df = await absrch(“FI:SOVR”)

With additional parameters

df = await absrch(“COMDTY:WEATHER”, LOCATION=“NYC”, MODEL=“GFS”)

abqr

async def abqr(ticker: str,
               date_offset: str | None = None,
               start_date: DateLike = None,
               end_date: DateLike = None,
               *,
               event_types: Sequence[str] | None = None,
               include_broker_codes: bool = True,
               include_spread_price: bool = False,
               include_yield: bool = False,
               include_condition_codes: bool = False,
               include_exchange_codes: bool = False,
               backend: Backend | str | None = None,
               **kwargs) -> DataFrameResult

Async Bloomberg Quote Request (BQR).

Retrieves dealer quote data using IntradayTickRequest with BID/ASK events. Emulates the Excel =BQR() function.

Arguments:

ticker - Security identifier. Supports Bloomberg tickers with pricing source qualifiers (e.g., ‘IBM US Equity@MSG1’, ‘/isin/US037833FB15@MSG1’).
date_offset - Date offset from now (e.g., ‘-2d’, ‘-1w’, ‘-3h’). Mutually exclusive with start_date/end_date.
start_date - Start date (e.g., ‘2024-01-15’). Defaults to 2 days ago.
end_date - End date (e.g., ‘2024-01-17’). Defaults to today.
event_types - Event types to retrieve. Defaults to [‘BID’, ‘ASK’].
include_broker_codes - Include broker/dealer codes (default True).
include_spread_price - Include spread price for bonds (default False).
include_yield - Include yield data for bonds (default False).
include_condition_codes - Include trade condition codes (default False).
include_exchange_codes - Include exchange codes (default False).
backend - DataFrame backend to return. If None, uses global default.
**kwargs - Additional options.

Returns:

DataFrame with columns: ticker, time, event_type, price, size, plus optional broker_buy, broker_sell, spread_price, etc.

Example::

With date offset (like Excel BQR)

df = await abqr(“IBM US Equity@MSG1”, date_offset=“-2d”)

Bond with broker codes and spread

df = await abqr( “US037833FB15@MSG1 Corp”, date_offset=“-2d”, include_broker_codes=True, include_spread_price=True, )

With explicit date range

df = await abqr( “XYZ 4.5 01/15/30@MSG1 Corp”, start_date=“2024-01-15”, end_date=“2024-01-17”, )

Trade events only

df = await abqr( “XYZ 4.5 01/15/30@MSG1 Corp”, date_offset=“-1d”, event_types=[“TRADE”], )

abflds

async def abflds(fields: str | list[str] | None = None,
                 *,
                 search_spec: str | None = None,
                 backend: Backend | str | None = None,
                 **kwargs) -> DataFrameResult

Async Bloomberg field metadata lookup (BFLDS).

Unified field function: get metadata for specific fields, or search by keyword.

Arguments:

fields - Single field or list of fields to get metadata for. Mutually exclusive with search_spec.
search_spec - Search term to find fields by name/description. Mutually exclusive with fields.
backend - DataFrame backend to return. If None, uses global default.
**kwargs - Infrastructure options (e.g., port, server).

Returns:

DataFrame with field information or search results.

Raises:

ValueError - If neither fields nor search_spec is provided, or both are provided.

Example::

Get info for specific fields
Section titled “Get info for specific fields”

df = await abflds(fields=[“PX_LAST”, “VOLUME”])

Search for fields by keyword
Section titled “Search for fields by keyword”

df = await abflds(search_spec=“vwap”)

abeqs

async def abeqs(screen: str,
                *,
                asof: str | None = None,
                screen_type: str = "PRIVATE",
                group: str = "General",
                backend: Backend | str | None = None,
                **kwargs) -> DataFrameResult

Async Bloomberg Equity Screening (BEQS) request.

Execute a saved Bloomberg equity screen and return matching securities.

Arguments:

screen - Screen name as saved in Bloomberg.
asof - As-of date for the screen. Accepts ISO 8601 / YYYYMMDD string, datetime.date, datetime.datetime, or pd.Timestamp.
screen_type - Screen type - “PRIVATE” (custom) or “GLOBAL” (Bloomberg).
group - Group name if screen is organized into groups.
backend - DataFrame backend to return. If None, uses global default.
**kwargs - Additional request parameters.

Returns:

DataFrame with columns from the screen results (security, fieldData, etc.).

Example::

Run a private screen

df = await abeqs(“MyScreen”)

Run with as-of date

df = await abeqs(“MyScreen”, asof=“20240101”)

Run a Bloomberg global screen

df = await abeqs(“TOP_DECL_DVD”, screen_type=“GLOBAL”)

ablkp

async def ablkp(query: str,
                *,
                yellowkey: str = "YK_FILTER_NONE",
                language: str = "LANG_OVERRIDE_NONE",
                max_results: int = 20,
                backend: Backend | str | None = None,
                **kwargs) -> DataFrameResult

Async Bloomberg security lookup (BLKP) request.

Search for securities by company name or partial ticker.

Arguments:

query - Search query (company name or partial ticker).
yellowkey - Asset class filter. Common values:
- “YK_FILTER_NONE” (default, all asset classes)
- “YK_FILTER_EQTY” (equities only)
- “YK_FILTER_CORP” (corporate bonds)
- “YK_FILTER_GOVT” (government bonds)
- “YK_FILTER_INDX” (indices)
- “YK_FILTER_CURR” (currencies)
- “YK_FILTER_CMDT” (commodities)
language - Language override for results.
max_results - Maximum number of results (default: 20, max: 1000).
backend - DataFrame backend to return. If None, uses global default.
**kwargs - Additional request parameters.

Returns:

DataFrame with columns: security, description, and other result fields.

Example::

Search for Apple

df = await ablkp(“Apple”)

Search for equities only

df = await ablkp(“NVDA”, yellowkey=“YK_FILTER_EQTY”)

Get more results

df = await ablkp(“Microsoft”, max_results=50)

abport

async def abport(portfolio: str,
                 fields: str | Sequence[str],
                 *,
                 backend: Backend | str | None = None,
                 **kwargs) -> DataFrameResult

Async Bloomberg portfolio data (BPORT) request.

Get portfolio holdings and related data using PortfolioDataRequest.

Arguments:

portfolio - Portfolio identifier/name.
fields - Field name or list of fields (e.g., “PORTFOLIO_MWEIGHT”).
backend - DataFrame backend to return. If None, uses global default.
**kwargs - Additional request parameters/overrides.

Returns:

DataFrame with portfolio data.

Example::

Get portfolio weights

df = await abport(“MY_PORTFOLIO”, “PORTFOLIO_MWEIGHT”)

Get multiple fields

df = await abport(“MY_PORTFOLIO”, [“PORTFOLIO_MWEIGHT”, “PORTFOLIO_POSITION”])

abcurves

async def abcurves(*,
                   country: str | None = None,
                   currency: str | None = None,
                   curve_type: str | None = None,
                   subtype: str | None = None,
                   curveid: str | None = None,
                   bbgid: str | None = None,
                   backend: Backend | str | None = None,
                   **kwargs) -> DataFrameResult

Async Bloomberg yield curve list (BCURVES) request.

Search for yield curves by country, currency, type, or other filters.

Arguments:

country - Country code filter (e.g., “US”, “GB”, “DE”).
currency - Currency code filter (e.g., “USD”, “EUR”, “GBP”).
curve_type - Curve type filter (e.g., “GOVERNMENT”, “CORPORATE”).
subtype - Curve subtype filter.
curveid - Specific curve ID to look up.
bbgid - Bloomberg Global ID filter.
backend - DataFrame backend to return. If None, uses global default.
**kwargs - Additional request parameters.

Returns:

DataFrame with yield curve information.

Example::

List US yield curves

df = await abcurves(country=“US”)

List USD government curves

df = await abcurves(currency=“USD”, curve_type=“GOVERNMENT”)

Look up specific curve

df = await abcurves(curveid=“YCSW0023 Index”)

abgovts

async def abgovts(query: str | None = None,
                  *,
                  partial_match: bool = True,
                  backend: Backend | str | None = None,
                  **kwargs) -> DataFrameResult

Async Bloomberg government securities list (BGOVTS) request.

Search for government securities by ticker or name.

Arguments:

query - Search query (ticker or partial name).
partial_match - If True, match partial ticker names (default: True).
backend - DataFrame backend to return. If None, uses global default.
**kwargs - Additional request parameters.

Returns:

DataFrame with government securities information.

Example::

Search for US Treasury securities

df = await abgovts(“T”)

Search for German government bonds

df = await abgovts(“DBR”)

Exact match only

df = await abgovts(“T 2.5 05/15/24”, partial_match=False)

afieldInfo

async def afieldInfo(fields: str | list[str],
                     *,
                     backend: Backend | str | None = None,
                     **kwargs) -> DataFrameResult

Get metadata about Bloomberg fields (async).

Convenience wrapper around abflds(fields=…).

Arguments:

fields - Single field or list of fields to get metadata for.
backend - DataFrame backend to return. If None, uses global default.
**kwargs - Infrastructure options.

Returns:

DataFrame with field information.

Example::

df = await afieldInfo([“PX_LAST”, “VOLUME”])

afieldSearch

async def afieldSearch(searchterm: str,
                       *,
                       backend: Backend | str | None = None,
                       **kwargs) -> DataFrameResult

Search for Bloomberg fields by keyword (async).

Convenience wrapper around abflds(search_spec=…).

Arguments:

searchterm - Search term to find fields by name/description.
backend - DataFrame backend to return. If None, uses global default.
**kwargs - Infrastructure options.

Returns:

DataFrame with search results.

Example::

df = await afieldSearch(“vwap”)

abops

async def abops(service: str | Service = Service.REFDATA) -> list[str]

List available operations for a Bloomberg service (async).

Arguments:

service - Service URI or Service enum (default: //blp/refdata)

Returns:

List of operation names.

Example::

ops = await abops() print(ops) [‘ReferenceDataRequest’, ‘HistoricalDataRequest’, …]

ops = await abops(“//blp/instruments”) print(ops) [‘InstrumentListRequest’, …]

abschema

async def abschema(service: str | Service = Service.REFDATA,
                   operation: str | Operation | None = None) -> dict

Get Bloomberg service or operation schema (async).

Returns introspected schema with element definitions, types, and enum values. Schemas are cached locally (~/.xbbg/schemas/) for fast subsequent access.

Arguments:

service - Service URI or Service enum (default: //blp/refdata)
operation - Optional operation name. If None, returns full service schema.

Returns:

Dictionary with schema information:

If operation is None: Full service schema with all operations
If operation is specified: Just that operation’s request/response schema

Example::

Get full service schema
Section titled “Get full service schema”

schema = await abschema() print(schema[‘operations’][0][‘name’]) ‘ReferenceDataRequest’

Get specific operation schema
Section titled “Get specific operation schema”

op_schema = await abschema(operation=“ReferenceDataRequest”) print(op_schema[‘request’][‘children’][0][‘name’]) ‘securities’

Get enum values for an element
Section titled “Get enum values for an element”

op = await abschema(operation=“HistoricalDataRequest”) for child in op[‘request’][‘children’]: … if child.get(‘enum_values’): … print(f”{child[‘name’]}: {child[‘enum_values’]}”)

Bloomberg Data API

xbbg.blp

Engine Objects

RequestEnvironment Objects

RequestContext Objects

add_middleware

remove_middleware

clear_middleware

get_middleware

set_middleware

shutdown

Explicit shutdown (optional - happens automatically on exit)

reset

Initial usage

Need different config? Reset first

is_connected

configure

Option 1: Using keyword arguments (most common)

Option 2: Using EngineConfig object

Option 3: EngineConfig + overrides

Option 4: B-PIPE / SAPI authentication

Option 5: Custom field cache location

set_backend

Use lazy evaluation for deferred computation

String also works

get_backend

arequest

Query field metadata (//blp/apiflds service)

Get raw JSON for debugging

Custom Bloomberg request (power user)

Raw request marker with explicit Bloomberg operation

abdp

Async usage

Concurrent requests

abdh

Async usage

Concurrent requests

abds

abdib

1-minute bars (default)

5-minute bars with explicit datetime range

10-second bars

abdtick

Tick Objects

Subscription Objects

batch is xbbg.ArrowRecordBatch

__init__

add

remove

tickers

failed_tickers

failures

topic_states

session_status

admin_status

service_status

events

status

fields

is_active

all_failed

stats

unsubscribe

asubscribe

Basic usage

With context manager

Dynamic add/remove

Tick mode (dict conversion)

astream

With callback

stream

avwap

Basic usage - subscribe to VWAP

With custom time window

With specific fields

amktbar

Subscribe to 5-minute bars

Multiple securities

adepth

Subscribe to market depth

init