Thanks to visit codestin.com
Credit goes to xbbg.org

xbbg

Appearance

Bloomberg Data API ​

xbbg.blp ​

Generated from py-xbbg/src/xbbg/blp.py and py-xbbg/src/xbbg/_exports.py in the xbbg source repository.

High-level Bloomberg data API: reference, historical, intraday, query, search, streaming, schema, and lifecycle helpers. The API is async-first; sync helpers wrap async implementations for scripts and notebooks.

Engine and lifecycle ​

Backend ​

python
class Backend(Enum):
    ...

Output backend selector used by request helpers and conversion utilities.

configure ​

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

Configure the global engine before its first Bloomberg request when the default local Terminal endpoint is not enough.

Default Terminal connection

You can skip configure() for the default local Bloomberg Terminal connection (localhost:8194). Use configure() only when you need non-default connection facts such as host lists, B-PIPE/SAPI auth, TLS, ZFP, SOCKS5, failover, worker pools, validation, or SDK logging.

Can be called with an EngineConfig object, keyword arguments, or both. Keyword arguments override fields from the provided config object.

Args: config: Optional EngineConfig object with connection and engine settings. **kwargs: Field overrides such as host, port, servers, auth_method, app_name, tls_client_credentials, zfp_remote, or socks5_host.

Raises: TypeError: If an unknown keyword argument is passed. ValueError: If a field combination is invalid. RuntimeWarning: If called after the engine already started; the existing engine is shut down and restarted with the new config on next use.

Example:

python
import xbbg

# Default local Terminal connection: no configure() call required.
df = xbbg.bdp('AAPL US Equity', 'PX_LAST')

# Non-default B-PIPE/SAPI connection.
xbbg.configure(
    servers=[('bpipe-primary.example.com', 8194), ('bpipe-secondary.example.com', 8194)],
    auth_method='app',
    app_name='<authorized-app-name>',
)

set_backend ​

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

Set the default DataFrame backend for all xbbg functions.

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

python

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
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
xbbg.set_backend("pandas")

get_backend ​

python
def get_backend() -> Backend | None:
    ...

Get the current default DataFrame backend.

Request middleware ​

RequestContext ​

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.

Generic requests ​

arequest ​

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

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

python

# 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"],
)

request ​

Exported by xbbg.blp from the package source. See the package surface page for grouping and usage context.

Reference, historical, and intraday data ​

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

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

python

# 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"),
)

bdp ​

python
def bdp(
    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: Any,
) -> DataFrameResult:
    ...

Sync Bloomberg reference data (BDP). See abdp for details.

abdh ​

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

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

python

# 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"),
)

bdh ​

python
def bdh(
    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: Any,
) -> DataFrameResult:
    ...

Sync Bloomberg historical data (BDH). See abdh for details.

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

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

python

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

bds ​

python
def bds(
    tickers: str | Sequence[str],
    flds: str,
    *,
    backend: Backend | str | None = None,
    validate_fields: bool | None = None,
    **kwargs: Any,
) -> DataFrameResult:
    ...

Sync Bloomberg bulk data (BDS). See abds for details.

abdib ​

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

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

python

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

bdib ​

python
def bdib(
    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: Any,
) -> DataFrameResult:
    ...

Sync Bloomberg intraday bar data (BDIB). See abdib for details.

abdtick ​

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

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

python

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

bdtick ​

python
def bdtick(
    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: Any,
) -> DataFrameResult:
    ...

Sync Bloomberg tick data (BDTICK). See abdtick for details.

Query, search, portfolio, and fields ​

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.

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

python

# 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))")

bql ​

python
def bql(
    expression: str,
    *,
    backend: Backend | str | None = None,
) -> DataFrameResult:
    ...

Sync Bloomberg Query Language (BQL) request. See abql for details.

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.

Args: domain: The saved search domain/name (e.g., "FI:SOVR", "COMDTY:PRECIOUS"). backend: DataFrame backend to return. If None, uses global default. **kwargs: Search parameters. Direct keyword arguments and explicit overrides={...} mappings or (name, value) pairs are sent as ExcelGetGrid overrides. Domain is sent as the request's top-level domain element.

Returns: DataFrame with columns from the saved search results.

Example:

python

# Sovereign bonds
df = await absrch("FI:SOVR")

# With additional parameters
df = await absrch("COMDTY:WEATHER", LOCATION="NYC", MODEL="GFS")

bsrch ​

python
def bsrch(
    domain: str,
    *,
    backend: Backend | str | None = None,
    **kwargs: Any,
) -> DataFrameResult:
    ...

Sync Bloomberg Search (BSRCH) request. See absrch for details.

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.

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

python

# 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")

beqs ​

python
def beqs(
    screen: str,
    *,
    asof: str | None = None,
    screen_type: str = "PRIVATE",
    group: str = "General",
    backend: Backend | str | None = None,
    **kwargs: Any,
) -> DataFrameResult:
    ...

Sync Bloomberg Equity Screening (BEQS) request. See abeqs for details.

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.

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

python

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

blkp ​

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

Sync Bloomberg security lookup (BLKP) request. See ablkp for details.

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.

Args: portfolio: Bloomberg PortfolioDataRequest security/portfolio ID string, not the PORT display name (for example, "UXXXXXXX-X Client" from PRTU/PORT). 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:

python

# Get portfolio overview data. Use the Bloomberg portfolio ID/security
# string, not the human-readable PORT display name.
df = await abport("UXXXXXXX-X Client", "PORTFOLIO_DATA")

# Get portfolio weights
df = await abport("UXXXXXXX-X Client", "PORTFOLIO_MWEIGHT")

bport ​

python
def bport(
    portfolio: str,
    fields: str | Sequence[str],
    *,
    backend: Backend | str | None = None,
    **kwargs: Any,
) -> DataFrameResult:
    ...

Sync Bloomberg portfolio data (BPORT) request. See abport for details.

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.

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

python

# Get info for specific fields
df = await abflds(fields=["PX_LAST", "VOLUME"])

# Search for fields by keyword
df = await abflds(search_spec="vwap")

bflds ​

python
def bflds(
    fields: str | list[str] | None = None,
    *,
    search_spec: str | None = None,
    backend: Backend | str | None = None,
    **kwargs: Any,
) -> DataFrameResult:
    ...

Sync Bloomberg field metadata lookup (BFLDS). See abflds for details.

abfld ​

Exported by xbbg.blp from the package source. See the package surface page for grouping and usage context.

bfld ​

Exported by xbbg.blp from the package source. See the package surface page for grouping and usage context.

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=...).

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

python

df = await afieldInfo(["PX_LAST", "VOLUME"])

fieldInfo ​

Exported by xbbg.blp from the package source. See the package surface page for grouping and usage context.

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=...).

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

python

df = await afieldSearch("vwap")

fieldSearch ​

Exported by xbbg.blp from the package source. See the package surface page for grouping and usage context.

Curves, governments, and quote requests ​

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.

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

python

# 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")

bcurves ​

python
def bcurves(
    *,
    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: Any,
) -> DataFrameResult:
    ...

Sync Bloomberg yield curve list (BCURVES) request. See abcurves for details.

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.

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

python

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

bgovts ​

python
def bgovts(
    query: str | None = None,
    *,
    partial_match: bool = True,
    backend: Backend | str | None = None,
    **kwargs: Any,
) -> DataFrameResult:
    ...

Sync Bloomberg government securities list (BGOVTS) request. See abgovts for details.

abqr ​

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

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

python

# 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"],
)

bqr ​

python
def bqr(
    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 = 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: Any,
) -> DataFrameResult:
    ...

Sync Bloomberg Quote Request (BQR). See abqr for details.

Realtime and streaming ​

Tick ​

python
class Tick:
    ...

Streaming tick record returned by realtime helpers.

Subscription ​

python
class Subscription:
    ...

Realtime subscription handle with explicit iteration and cleanup lifecycle.

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 | Service | None = None,
    options: list[str] | None = None,
    conflate: bool = False,
    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).

Args: 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'). For BPS services such as //blp/mktbar and //blp/mktvwap, tickers are normalized to explicit service topics. options: List of subscription options. If provided, uses subscribe_with_options conflate: If True, request Bloomberg conflated market data for //blp/mktdata. Quote updates are conflated by Bloomberg; trades are still delivered as received. 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:

python

# 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, ...}

subscribe ​

Exported by xbbg.blp from the package source. See the package surface page for grouping and usage context.

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[[Any], None] | None = None,
    tick_mode: bool = False,
    conflate: 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.

Args: 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 conflate: If True, request Bloomberg conflated market data for //blp/mktdata.

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

Example:

python

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[[Any], None] | None = None,
    tick_mode: bool = False,
    conflate: 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.

Args: 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 conflate: If True, request Bloomberg conflated market data for //blp/mktdata.

Yields: Batches of market data

Example:

python

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

avwap ​

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

Subscribe to real-time VWAP data.

Uses Bloomberg's //blp/mktvwap service. Bloomberg requires explicit Market VWAP topics (for example, //blp/mktvwap/ticker/IBM US Equity) and VWAP as the single requested field. Security identifiers passed here are normalized to those explicit topics.

Args: tickers: Security identifier(s). Plain tickers use the ticker topic type; already-qualified //blp/mktvwap/... topics pass through unchanged. start_time: Optional VWAP calculation start time (e.g., "09:30"). end_time: Optional VWAP calculation end time (e.g., "16:00"). raw: If True, yield raw Arrow RecordBatches for max performance. all_fields: If True, expose the full top-level VWAP payload. backend: DataFrame backend for batch conversion (ignored if raw=True).

Returns: Subscription handle for iteration and control.

Example:

python

# Basic usage - subscribe to VWAP
sub = await xbbg.avwap("IBM US Equity")
async for batch in sub:
    print(batch)
await sub.unsubscribe()

# With custom time window
sub = await xbbg.avwap(["IBM US Equity", "MSFT US Equity"], start_time="09:30", end_time="16:00")

vwap ​

Exported by xbbg.blp from the package source. See the package surface page for grouping and usage context.

amktbar ​

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

Subscribe to real-time streaming OHLC bars.

Uses Bloomberg's //blp/mktbar service. Bloomberg requires explicit market-bar topics (for example, //blp/mktbar/ticker/ES1 Index), LAST_PRICE as the only requested field, and bar_size as the bar interval option. Security identifiers passed here are normalized to those explicit topics.

Args: tickers: Security identifier(s). Plain tickers use the ticker topic type; identifiers like /figi/... keep their identifier type. bar_size: 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 the full top-level market-bar payload. backend: DataFrame backend to return. If None, uses global default.

Returns: Subscription object for async iteration.

Example:

python

# Subscribe to 5-minute bars
async with await amktbar("AAPL US Equity", bar_size=5) as sub:
    async for batch in sub:
        print(batch)

# Multiple securities
sub = await amktbar(["AAPL US Equity", "MSFT US Equity"], bar_size=1)
async for batch in sub:
    print(batch)

mktbar ​

Exported by xbbg.blp from the package source. See the package surface page for grouping and usage context.

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 a Bloomberg B-PIPE environment and applicable service entitlements. This feature is not available with Terminal-only connections.

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

Args: 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 a B-PIPE environment or service entitlement is unavailable.

Example:

python

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

depth ​

Exported by xbbg.blp from the package source. See the package surface page for grouping and usage context.

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 a Bloomberg B-PIPE environment and applicable service entitlements. This feature is not available with Terminal-only connections.

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

Args: 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 a B-PIPE environment or service entitlement is unavailable.

Example:

python

# 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")

chains ​

Exported by xbbg.blp from the package source. See the package surface page for grouping and usage context.

Technical analysis ​

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.

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

python

# 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")

bta ​

Exported by xbbg.blp from the package source. See the package surface page for grouping and usage context.

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:

python

>>> 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.

Args: study: Study name (e.g., 'rsi', 'macd', 'boll')

Returns: Dictionary of parameter names and their default values

Example:

python

>>> 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.

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

Returns: Path to the generated stub file.

Example:

python

>>> 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}

Schema and service helpers ​

abops ​

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

List available operations for a Bloomberg service (async).

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

Returns: List of operation names.

Example:

python

>>> ops = await abops()
>>> print(ops)
['ReferenceDataRequest', 'HistoricalDataRequest', ...]

>>> ops = await abops("//blp/instruments")
>>> print(ops)
['InstrumentListRequest', ...]

bops ​

Exported by xbbg.blp from the package source. See the package surface page for grouping and usage context.

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.

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

python

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

bschema ​

Exported by xbbg.blp from the package source. See the package surface page for grouping and usage context.

Service ​

python
class Service(Enum):
    ...

Bloomberg service identifier enum.

Operation ​

python
class Operation(Enum):
    ...

Bloomberg operation identifier enum.

OutputMode ​

python
class OutputMode(Enum):
    ...

Extractor output mode selector.

RequestParams ​

python
class RequestParams:
    ...

Typed low-level Bloomberg request parameter container.

ExtractorHint ​

python
class ExtractorHint(Enum):
    ...

Extractor selection hint for generic requests.

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.