Recipes and analytics

Bloomberg workflows as Engine and Ext methods.

Recipes run multi-step Bloomberg workflows in the shared Rust recipe layer — the same implementation behind Python xbbg.ext and Node.js @xbbg/core — and return typed Tables or any Backend<T>.

WARNING

Recipes send ordinary Bloomberg requests. They need the same connectivity and entitlements as the underlying fields and services.

How recipes behave

• Recipes are methods on Engine (plus Blp.delayStatus, Blp.subscribeAuction, Blp.streamAuction, Blp.subscribeEtfInav, and Cdx.acdxInfo/acdxPricing/acdxRisk on the configured shared engine).
• Every recipe returns CompletableFuture<Table> by default, and has an overload taking any Backend<T> (Backend.ROWS, Backend.IPC_STREAM, Backend.IPC_FILE, or ArrowBackends.vectorSchemaRoot(allocator)).
• Methods that accept one or many securities provide both String and Collection<String> overloads. Positional date arguments provide both String ("YYYY-MM-DD" or "YYYYMMDD") and java.time.TemporalAccessor (LocalDate, Instant, ...) overloads.
• Synchronous, engine-free utilities live in io.github.underloam.xbbg.ext.Ext and AuctionFields.

Fixed income

import io.github.underloam.xbbg.BqrOptions;
import io.github.underloam.xbbg.CorporateBondsOptions;
import io.github.underloam.xbbg.Engine;
import io.github.underloam.xbbg.PreferredsOptions;
import io.github.underloam.xbbg.Xbbg;
import io.github.underloam.xbbg.YasOptions;
import io.github.underloam.xbbg.table.Table;
import java.time.LocalDate;
import java.util.Arrays;

public class FixedIncomeRecipesExample {
  public static void main(String[] args) {
    try (Engine engine = Engine.open()) {
      // Yield and spread analysis (YAS); yieldType 1 is yield to maturity
      Table yas =
          Xbbg.await(
              engine.yas(
                  "US912810TM69 Govt",
                  "YAS_BOND_YLD",
                  YasOptions.builder()
                      .settleDt(LocalDate.of(2024, 1, 15))
                      .yieldType(1)
                      .price(99.5)
                      .build()));

      // Dealer quotes with broker attribution (BQR)
      Table quotes =
          Xbbg.await(
              engine.bqr(
                  "/isin/US037833FB15@MSG1 Corp",
                  BqrOptions.builder()
                      .startDatetime("2024-06-03T14:30:00")
                      .endDatetime("2024-06-03T15:00:00")
                      .build()));

      // Issuer preferreds and corporate bonds through BQL debt() universes
      Table preferreds =
          Xbbg.await(
              engine.preferreds(
                  "BAC US Equity",
                  PreferredsOptions.builder().fields(Arrays.asList("cpn")).build()));
      Table bonds =
          Xbbg.await(
              engine.corporateBonds(
                  "AAPL",
                  CorporateBondsOptions.builder()
                      .ccy("USD")
                      .fields(Arrays.asList("name", "cpn"))
                      .build()));

      // Curve and government security lookups on //blp/instruments
      Table curves = Xbbg.await(engine.bcurves("YCSW0023 Index"));
      Table govts = Xbbg.await(engine.bgovts("USD"));

      System.out.println(yas + " / " + quotes + " / " + preferreds + " / " + bonds + " / " + curves + " / " + govts);
    }
  }
}

Engine method	Options builder	Fields
yas(tickers, fields[, YasOptions][, Backend])	YasOptions.builder()	settleDt, yieldType (1..9), spread, yieldVal, price, benchmark.
bqr(ticker[, BqrOptions][, Backend])	BqrOptions.builder()	startDatetime, endDatetime, eventTypes (default BID, ASK), includeBrokerCodes (default true).
preferreds(equityTicker[, PreferredsOptions][, Backend])	PreferredsOptions.builder()	fields requested after default id, name.
corporateBonds(ticker[, CorporateBondsOptions][, Backend])	CorporateBondsOptions.builder()	ccy currency filter and extra fields after default id.
bcurves(ticker[, RequestOptions][, Backend]), bgovts(ticker[, RequestOptions][, Backend])	RequestOptions.builder()	kwargs for additional request elements (overrides are rejected).

Futures and CDX

import io.github.underloam.xbbg.ActiveCdxOptions;
import io.github.underloam.xbbg.CdxFields;
import io.github.underloam.xbbg.CdxOptions;
import io.github.underloam.xbbg.CdxResolveOptions;
import io.github.underloam.xbbg.Engine;
import io.github.underloam.xbbg.FuturesCurveOptions;
import io.github.underloam.xbbg.FuturesResolveOptions;
import io.github.underloam.xbbg.Xbbg;
import io.github.underloam.xbbg.ext.Cdx;
import io.github.underloam.xbbg.table.Table;
import java.time.LocalDate;

public class FuturesAndCdxExample {
  public static void main(String[] args) {
    try (Engine engine = Engine.open()) {
      LocalDate asof = LocalDate.of(2024, 3, 1);

      Table front = Xbbg.await(engine.futTicker("ES1 Index", asof));
      Table active =
          Xbbg.await(
              engine.activeFutures(
                  "CL1 Comdty",
                  asof,
                  FuturesResolveOptions.builder().freq("M").build()));
      Table curve =
          Xbbg.await(
              engine.futuresCurve(
                  "ES1 Index",
                  FuturesCurveOptions.builder().asof(asof).maxContracts(6).build()));

      // On-the-run CDX series on a date, and the latest series with trading activity
      Table series =
          Xbbg.await(
              engine.cdxTicker(
                  "CDX IG CDSI GEN 5Y Corp",
                  asof,
                  CdxResolveOptions.builder().versionless(false).build()));
      Table traded =
          Xbbg.await(
              engine.activeCdx(
                  "CDX IG CDSI GEN 5Y Corp",
                  asof,
                  ActiveCdxOptions.builder().lookbackDays(10).build()));

      // CDX reference-data bundles (also available on Cdx.acdxInfo / acdxPricing / acdxRisk)
      Table info = Xbbg.await(engine.acdxInfo("CDX IG CDSI GEN 5Y Corp"));
      Table pricing =
          Xbbg.await(
              engine.acdxPricing(
                  "CDX IG CDSI GEN 5Y Corp",
                  CdxOptions.builder().recoveryRate(40.0).build()));
      Table risk =
          Xbbg.await(
              Cdx.acdxRisk(
                  "CDX IG CDSI GEN 5Y Corp",
                  CdxOptions.builder().recoveryRate(40.0).build()));

      System.out.println(CdxFields.PRICING + ": " + front + active + curve + series + traded + info + pricing + risk);
    }
  }
}

• futTicker and activeFutures take FuturesResolveOptions (freq("Q") or "QE" for quarterly cycles; anything else is monthly).
• futuresCurve takes FuturesCurveOptions (asof, chainField, fields, maxContracts).
• cdxTicker takes CdxResolveOptions (versionless), and activeCdx takes ActiveCdxOptions (lookbackDays, versionless).
• The CDX field bundles (CdxFields.INFO, CdxFields.PRICING, CdxFields.RISK) run through engine.acdxInfo, engine.acdxPricing, and engine.acdxRisk (or Cdx.acdxInfo, Cdx.acdxPricing, and Cdx.acdxRisk on the shared engine). CdxOptions.Builder#recoveryRate(Double) sends the percentage as the CDS_RR override.

Dividends, turnover, holdings, indices, and volatility

import io.github.underloam.xbbg.DividendOptions;
import io.github.underloam.xbbg.DividendYieldOptions;
import io.github.underloam.xbbg.Engine;
import io.github.underloam.xbbg.EtfHoldingsOptions;
import io.github.underloam.xbbg.IndexMemberField;
import io.github.underloam.xbbg.IndexMembersOptions;
import io.github.underloam.xbbg.TurnoverOptions;
import io.github.underloam.xbbg.VolSurfaceOptions;
import io.github.underloam.xbbg.VolSurfacePreset;
import io.github.underloam.xbbg.Xbbg;
import io.github.underloam.xbbg.table.Table;
import java.time.LocalDate;
import java.util.Collections;

public class EquityAndVolRecipesExample {
  public static void main(String[] args) {
    try (Engine engine = Engine.open()) {
      Table dividends =
          Xbbg.await(
              engine.dividend(
                  "AAPL US Equity",
                  LocalDate.of(2023, 1, 1),
                  LocalDate.of(2023, 12, 31),
                  DividendOptions.builder().dvdType("all").build()));

      Table yield =
          Xbbg.await(
              engine.dividendYield(
                  "AAPL US Equity",
                  "2023-01-01",
                  "2023-12-31",
                  DividendYieldOptions.builder()
                      .dividendTypes(Collections.singletonList("Regular Cash"))
                      .windowDays(365)
                      .build()));

      Table turnover =
          Xbbg.await(
              engine.turnover(
                  "AAPL US Equity",
                  "2024-01-01",
                  "2024-01-31",
                  TurnoverOptions.builder().ccy("USD").factor(1e6).build()));

      Table holdings =
          Xbbg.await(
              engine.etfHoldings(
                  "SPY US Equity",
                  EtfHoldingsOptions.builder()
                      .fields(Collections.singletonList("name"))
                      .build()));

      Table members =
          Xbbg.await(
              engine.indexMembers(
                  "SPX Index",
                  IndexMembersOptions.builder()
                      .field(IndexMemberField.INDX_MWEIGHT)
                      .asof("2024-01-02")
                      .build()));

      Table surface =
          Xbbg.await(
              engine.volSurface(
                  "SPX Index",
                  "2024-01-02",
                  "2024-01-05",
                  VolSurfaceOptions.builder()
                      .preset(VolSurfacePreset.MONEYNESS_30D)
                      .includeDerived(true)
                      .riskFreeRate(0.05)
                      .build()));

      System.out.println(dividends + " / " + yield + " / " + turnover + " / " + holdings + " / " + members + " / " + surface);
    }
  }
}

Identifiers, currency conversion, and ETF NAV/iNAV

import io.github.underloam.xbbg.Engine;
import io.github.underloam.xbbg.Xbbg;
import io.github.underloam.xbbg.subscription.Subscription;
import io.github.underloam.xbbg.subscription.Tick;
import io.github.underloam.xbbg.table.Table;
import java.util.Arrays;

public class IdentifiersCcyAndEtfNavExample {
  public static void main(String[] args) {
    try (Engine engine = Engine.open()) {
      // Equity ISIN -> ticker, and bond ISIN -> issuer equity
      Table equities =
          Xbbg.await(engine.resolveIsins(Arrays.asList("US0378331005", "INVALIDISIN000")));
      Table issuers =
          Xbbg.await(engine.issuerIsins(Arrays.asList("US037833FB15", "INVALIDISIN000")));

      // Daily PX_LAST history converted with Bloomberg's CRNCY override
      Table usdHistory =
          Xbbg.await(
              engine.currencyConversion(
                  "700 HK Equity", "USD", "2024-01-01", "2024-01-31"));

      // ETF NAV and iNAV relationships, snapshot, history, and live iNAV stream
      Table relationships =
          Xbbg.await(
              engine.etfNavRelationships(Arrays.asList("QQQ US Equity", "AT1 LN Equity")));
      Table navSnapshot =
          Xbbg.await(engine.etfNavSnapshot(Arrays.asList("QQQ US Equity", "AT1 LN Equity")));
      Table navHistory =
          Xbbg.await(
              engine.etfNavHistory(
                  Arrays.asList("QQQ US Equity", "AT1 LN Equity"),
                  "2026-06-01",
                  "2026-07-01"));

      try (Subscription inav = Xbbg.await(engine.subscribeEtfInav("QQQ US Equity"))) {
        for (Tick tick : inav) {
          System.out.println(tick.topic() + " iNAV=" + tick.get("LAST_PRICE"));
          break;
        }
      }

      System.out.println(equities + " / " + issuers + " / " + usdHistory + " / " + relationships + " / " + navSnapshot + " / " + navHistory);
    }
  }
}

Exchange auctions and order imbalance

Bloomberg publishes auction and order-imbalance fields on the primary listing venue rather than the composite ticker. resolveVenues, auctionSnapshot, subscribeAuction, and streamAuction route each security or ISIN to its validated primary auction venue:

import io.github.underloam.xbbg.AuctionSnapshotOptions;
import io.github.underloam.xbbg.DelayedPolicy;
import io.github.underloam.xbbg.Engine;
import io.github.underloam.xbbg.ResolveVenuesOptions;
import io.github.underloam.xbbg.Xbbg;
import io.github.underloam.xbbg.ext.AuctionFields;
import io.github.underloam.xbbg.ext.ImbalanceSide;
import io.github.underloam.xbbg.subscription.AuctionStreamOptions;
import io.github.underloam.xbbg.subscription.Subscription;
import io.github.underloam.xbbg.subscription.Tick;
import io.github.underloam.xbbg.table.Table;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Optional;

public class AuctionsExample {
  public static void main(String[] args) {
    try (Engine engine = Engine.open()) {
      Table venues =
          Xbbg.await(
              engine.resolveVenues(
                  Arrays.asList("SPY US Equity", "IBM US Equity", "US0378331005"),
                  ResolveVenuesOptions.defaults()));

      List<String> fields = new ArrayList<String>(AuctionFields.imbalance());
      fields.addAll(AuctionFields.quotes());

      Table snapshot =
          Xbbg.await(
              engine.auctionSnapshot(
                  Collections.singletonList("IBM US Equity"),
                  AuctionSnapshotOptions.builder().fields(fields).build()));

      AuctionStreamOptions streamOpts =
          AuctionStreamOptions.builder()
              .fields(AuctionFields.defaults())
              .onDelayed(DelayedPolicy.RAISE)
              .build();

      try (Subscription auction =
          Xbbg.await(
              engine.subscribeAuction(
                  Arrays.asList("SPY US Equity", "IBM US Equity"), streamOpts))) {
        for (Tick tick : auction) {
          Optional<ImbalanceSide> side =
              AuctionFields.imbalanceSide(tick.getString("IMBALANCE_INDIC_RT").orElse(""));
          System.out.println(tick.topic() + " side=" + side);
          break;
        }
      }

      System.out.println(venues + " / " + snapshot);
    }
  }
}

• AuctionFields exposes read-only field groups: imbalance(), indicative(), state(), halts(), results(), composite(), quotes(), defaults(), zeroPriceFields(), group(name), and imbalanceSide(code) (mapping "BUY"/"MBUY"/"RBUY" to ImbalanceSide.BUY, "SELL"/"MSEL"/"RSEL" to ImbalanceSide.SELL, "NOIM"/"NIMB" to ImbalanceSide.NONE, and unknown/undisclosed codes to Optional.empty()).

Entitlements and delayed data

import io.github.underloam.xbbg.BdtickOptions;
import io.github.underloam.xbbg.DelayStatusOptions;
import io.github.underloam.xbbg.Engine;
import io.github.underloam.xbbg.EntitlementReport;
import io.github.underloam.xbbg.SeatType;
import io.github.underloam.xbbg.Xbbg;
import io.github.underloam.xbbg.table.Table;
import java.util.Arrays;
import java.util.Collection;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;

public class EntitlementsExample {
  public static void main(String[] args) {
    try (Engine engine = Engine.open()) {
      SeatType seat = Xbbg.await(engine.seatType());
      boolean authorized = Xbbg.await(engine.identityIsAuthorized("//blp/mktdata"));
      System.out.println("Seat: " + seat + ", mktdata authorized: " + authorized);

      Table ticks =
          Xbbg.await(
              engine.bdtick(
                  "AAPL US Equity",
                  BdtickOptions.builder()
                      .start("2024-01-15T14:30:00")
                      .end("2024-01-15T15:00:00")
                      .returnEids(true)
                      .build()));

      Set<Integer> eids = new LinkedHashSet<Integer>();
      ticks
          .eidData()
          .ifPresent(
              map -> {
                for (Collection<Integer> list : map.values()) {
                  eids.addAll(list);
                }
              });

      if (!eids.isEmpty()) {
        EntitlementReport report = Xbbg.await(engine.checkEntitlements("//blp/refdata", eids));
        System.out.println("Entitled: " + report.entitled() + ", failed EIDs: " + report.failedEids());
      }

      Table delayStatus =
          Xbbg.await(
              engine.delayStatus(
                  Arrays.asList("VOD LN Equity", "AAPL US Equity"),
                  DelayStatusOptions.builder().checkIdentity(false).build()));
      System.out.println("Delay status rows: " + delayStatus.numRows());
    }
  }
}

Fields, schemas, and other Engine requests

import io.github.underloam.xbbg.BeqsOptions;
import io.github.underloam.xbbg.BtaOptions;
import io.github.underloam.xbbg.BtaStudy;
import io.github.underloam.xbbg.Engine;
import io.github.underloam.xbbg.RequestSpec;
import io.github.underloam.xbbg.Xbbg;
import io.github.underloam.xbbg.table.Table;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Optional;

public class SchemaAndRequestsExample {
  public static void main(String[] args) {
    try (Engine engine = Engine.open()) {
      // Field metadata and validation
      Table info = Xbbg.await(engine.fieldInfo(Arrays.asList("PX_LAST", "VOLUME")));
      Map<String, String> types =
          Xbbg.await(engine.resolveFieldTypes(Arrays.asList("PX_LAST", "SECURITY_NAME")));
      List<String> invalid =
          Xbbg.await(engine.validateFields(Arrays.asList("PX_LAST", "NOT_A_FIELD")));

      // Service and operation schema introspection
      List<String> ops = Xbbg.await(engine.bops("//blp/refdata"));
      String histSchema = Xbbg.await(engine.bschema("//blp/refdata", "HistoricalDataRequest"));
      Optional<List<String>> periodicities =
          Xbbg.await(
              engine.getEnumValues(
                  "//blp/refdata", "HistoricalDataRequest", "periodicitySelection"));

      // Equity screens (BEQS), saved searches (BSRCH), technical analysis (BTA), lookups (BLKP)
      Table screen =
          Xbbg.await(
              engine.beqs("MyScreen", BeqsOptions.builder().asof("2024-01-02").build()));
      Table grid = Xbbg.await(engine.bsrch("FI:SOVR"));
      Table rsi =
          Xbbg.await(
              engine.bta(
                  "AAPL US Equity",
                  BtaStudy.builder("rsi").calcInterval("DAILY").build(),
                  BtaOptions.builder()
                      .startDate("2024-01-01")
                      .endDate("2024-06-30")
                      .studyParams(Collections.singletonMap("period", 9))
                      .build()));
      Table lookup = Xbbg.await(engine.blkp("IBM"));

      // Generic request builder (RequestSpec)
      Table generic =
          Xbbg.await(
              engine.request(
                  RequestSpec.builder("//blp/refdata")
                      .operation("ReferenceDataRequest")
                      .securities(Collections.singletonList("AAPL US Equity"))
                      .fields(Collections.singletonList("PX_LAST"))
                      .build()));

      System.out.println(
          info
              + " / "
              + types
              + " / "
              + invalid
              + " / "
              + ops.size()
              + " / "
              + histSchema.length()
              + " / "
              + periodicities
              + " / "
              + screen
              + " / "
              + grid
              + " / "
              + rsi
              + " / "
              + lookup
              + " / "
              + generic);
    }
  }
}

Synchronous native utilities in Ext

io.github.underloam.xbbg.ext.Ext exposes the synchronous native utilities that run in-process without a Bloomberg session:

import io.github.underloam.xbbg.ext.CdxTickerInfo;
import io.github.underloam.xbbg.ext.ExchangeOverride;
import io.github.underloam.xbbg.ext.Ext;
import io.github.underloam.xbbg.ext.FxPairInfo;
import io.github.underloam.xbbg.ext.MarketRule;
import io.github.underloam.xbbg.ext.SessionWindows;
import io.github.underloam.xbbg.ext.TickerParts;
import io.github.underloam.xbbg.ext.TimeRange;
import java.util.Optional;

public class ExtUtilitiesExample {
  public static void main(String[] args) {
    TickerParts parts = Ext.parseTicker("ES1 Index");
    CdxTickerInfo cdx = Ext.parseCdxTicker("CDX IG CDSI GEN 5Y Corp");
    FxPairInfo fx = Ext.buildFxPair("GBp", "USD");
    Optional<MarketRule> nyse = Ext.getMarketRule("XNYS", "US");
    SessionWindows sessions = Ext.deriveSessions("09:30", "16:00", "XNYS", "US");

    Ext.setExchangeOverride(
        "TEST US Equity",
        ExchangeOverride.builder()
            .timezone("America/New_York")
            .mic("XNYS")
            .day(new TimeRange("09:30", "16:00"))
            .build());

    System.out.println(parts + " / " + cdx + " / " + fx + " / " + nyse + " / " + sessions);
    Ext.clearExchangeOverride("TEST US Equity");
  }
}

See the Java API Surface for the complete list of Ext methods and return types.

Related pages

Output Formats

Pass Backend.ROWS, Backend.IPC_STREAM, or ArrowBackends.vectorSchemaRoot to any recipe.

Streaming

Consume subscribeAuction, streamAuction, and subscribeEtfInav streams.

API Surface

Complete method and option-builder reference.

Node.js recipes

The matching recipe surface in @xbbg/core.