xbbg

Appearance

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 (bdp, bdh, etc.) wrap async with asyncio.run()
  • Generic API: arequest() and request() for power users and arbitrary Bloomberg requests
  • Users can use either style based on their needs

Engine Objects ​

python
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 ​

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

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

RequestContext Objects ​

python
@dataclass(slots=True)
class RequestContext()

Mutable context object passed through the request middleware chain.

add_middleware ​

python
def add_middleware(middleware: RequestMiddleware) -> RequestMiddleware

Register a request middleware callable.

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 ​

python
def remove_middleware(middleware: RequestMiddleware) -> None

Remove a previously registered middleware callable.

clear_middleware ​

python
def clear_middleware() -> None

Remove all registered middleware.

get_middleware ​

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

Return the currently registered middleware chain.

set_middleware ​

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

Replace the current middleware chain.

shutdown ​

python
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::

python
def reset() -> None
```python
def is_connected() -> bool
```python
def configure(config=None, **kwargs) -> None

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::
  
```python
def set_backend(backend: Backend | str | None) -> None
```python
def get_backend() -> Backend | None
```python
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: str | None = None,
        end_date: str | None = None,
        start_datetime: str | None = None,
        end_datetime: str | None = 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)
- `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"],
  )

<a id="xbbg.blp.abdp"></a>

#### abdp

```python
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 ​

python
async def abdh(tickers: str | Sequence[str],
               flds: str | Sequence[str] | None = None,
               start_date: str | None = None,
               end_date: str = "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 ​

python
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 bulk data, multiple rows per ticker.

Example::

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

abdib ​

python
async def abdib(ticker: str,
                dt: str | None = None,
                session: str = "allday",
                typ: str = "TRADE",
                *,
                start_datetime: str | None = None,
                end_datetime: str | None = 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). Pass field overrides via overrides={"Points": 1} (dict) or overrides=[("Points", 1)] (list of tuples).

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 ​

python
async def abdtick(ticker: str,
                  start_datetime: str,
                  end_datetime: str,
                  *,
                  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. Pass field overrides via
  • ```overrides={"Points"` - 1}(dict) oroverrides=[("Points", 1)]`` (list of tuples). Schema-recognized request elements may be passed as individual keyword arguments.

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 ​

python
@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 ​

python
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 pyarrow.RecordBatch ​

print(batch.to_pandas())

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

await sub.unsubscribe()

__init__ ​

python
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)

__anext__ ​

python
async def __anext__() -> pa.RecordBatch | nw.DataFrame | dict[str, Any]

Get next batch of data.

add ​

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

Add tickers to subscription dynamically.

Arguments:

  • tickers - Single ticker or list of tickers to add

remove ​

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

Remove tickers from subscription dynamically.

Arguments:

  • tickers - Single ticker or list of tickers to remove

tickers ​

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

Currently active tickers.

failed_tickers ​

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

Tickers Bloomberg rejected or terminated.

failures ​

python
@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 ​

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

Topic lifecycle state keyed by ticker/topic.

session_status ​

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

Session-level connection status for this subscription.

admin_status ​

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

Bloomberg admin/slow-consumer status for this subscription.

service_status ​

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

Service availability status keyed by Bloomberg service name.

events ​

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

Bounded lifecycle/event history for the subscription.

status ​

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

Combined operational status snapshot.

fields ​

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

Subscribed fields.

is_active ​

python
@property
def is_active() -> bool

Whether the subscription is still active.

all_failed ​

python
@property
def all_failed() -> bool

Whether every requested ticker has ended in failure/termination.

stats ​

python
@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 ​

python
async def unsubscribe(drain: bool = False) -> list[pa.RecordBatch] | 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 ​

python
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) -> 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, convert batches to dicts (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) #

astream ​

python
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[[pa.RecordBatch | nw.DataFrame | dict[str, 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 ​

python
def stream(tickers: str | list[str],
           fields: str | list[str],
           *,
           raw: bool = False,
           all_fields: bool = False,
           backend: Backend | str | None = None,
           callback: Callable[[pa.RecordBatch | nw.DataFrame | dict[str, 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 ​

python
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::

Basic usage - subscribe to VWAP ​

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 ​

python
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 pyarrow RecordBatch (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::

Subscribe to 5-minute bars ​

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 ​

python
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 pyarrow RecordBatch (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 ​

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

achains ​

python
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 pyarrow RecordBatch (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 ​

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

    Subscribe to futures chain ​

    sub = await achains("ES1 Index", chain_type="FUTURES")

abta ​

python
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 (YYYYMMDD format)
  • end_date - End date (YYYYMMDD format)
  • 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 ​

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

    RSI with 14-day period ​

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

    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 ​

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

    Intraday RSI with 60-minute bars ​

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

    Multiple securities (sends concurrent requests) ​

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

ta_studies ​

python
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 ​

python
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 ​

python
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 =

abql ​

python
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, field1, field2, ... 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 ​

python
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 ​

python
async def abqr(ticker: str,
               date_offset: str | None = None,
               start_date: str | None = None,
               end_date: str | None = None,
               *,
               event_types: Sequence[str] | None = None,
               include_broker_codes: bool = False,
               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 False).
  • 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, type, value, size, plus optional brokerBuyCode, brokerSellCode, spreadPrice, 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 ​

python
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 ​

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

    Search for fields by keyword ​

    df = await abflds(search_spec="vwap")

abeqs ​

python
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 (YYYYMMDD format).
  • 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 ​

python
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 ​

python
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 ​

python
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 ​

python
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 ​

python
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 ​

python
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 ​

python
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 ​

python
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 ​

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

Get specific operation schema ​

op_schema = await abschema(operation="ReferenceDataRequest") print(op_schema['request']['children'][0]['name']) 'securities'

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']}")

xbbg is independent open-source software and is not affiliated with, endorsed by, sponsored by, or approved by Bloomberg Finance L.P.

Bloomberg and related marks are trademarks or service marks of Bloomberg Finance L.P. or its affiliates. Use of Bloomberg data, APIs, and SDKs requires appropriate Bloomberg licenses and entitlements.