Skip to main content
AGG’s live crypto market API lets prediction market apps discover recurring crypto markets and fetch fresh underlying reference prices through one integration. Build BTC, ETH, SOL, XRP, DOGE, HYPE, and other crypto market views without wiring every venue’s market format and reference-price source separately. Use it for crypto prediction market pages, trading dashboards, agent workflows, and cross-venue price comparison. Recurring crypto markets are short-window markets such as “BTC up or down in the next 15 minutes”. They need two separate data reads:
  1. Market discovery tells you which venue markets exist for an asset and window.
  2. Reference prices tell you the current underlying asset price used to evaluate the market.
Use discovery responses to build cards, tables, and filters. Poll the reference-price endpoint when you need the current BTC/USD, ETH/USD, or other underlying price.

​
Endpoint map

Use caseAPI Reference
Browse all recurring crypto windowsList recurring crypto window markets
Poll current underlying pricesGet live crypto reference prices
Browse all venue events by cadenceList venue events
Fetch live venue orderbooksGet live orderbooks for multiple markets
Reference prices are underlying asset prices, not prediction-market prices. A BTC/USD reference price belongs next to market odds; it should not be treated as a Yes/No midpoint.

​
What you get

  • Deterministic windows grouped by asset, quoteAsset, duration, windowStart, and windowEnd.
  • Venue market rows for each window, including outcomes, midpoint-style market odds, metrics, routeability flags, and reference-price metadata.
  • Fresh USD reference prices with softRefreshMs, hardMaxAgeMs, ageMs, stale, and target-level error fields so your UI can degrade cleanly.
  • Cross-venue comparison fields for reference prices and up/down outcome prices.

​
Cadence filters

AGG exposes recurrence filters as fixed enum values. There is no separate cadence catalog endpoint to call from your frontend. Venue event discovery accepts the full recurrence enum, while recurring crypto discovery currently supports the short-window crypto durations listed below.
Crypto market durationAPI value
5 minutesPT5M
15 minutesPT15M
1 hourPT1H
DailyP1D
Venue event discovery also accepts broader recurrence filters:
LabelAPI value
5 minutesPT5M
10 minutesPT10M
15 minutesPT15M
1 hourPT1H
DailyP1D
WeeklyP1W
MonthlyP1M
YearlyP1Y
One-off eventsnull
The SDK exports the supported cadence list: 
import { RECURRENCE_CADENCES } from "@agg-build/sdk";

console.log(RECURRENCE_CADENCES);
// ["PT5M", "PT10M", "PT15M", "PT1H", "P1D", "P1W", "P1M", "P1Y"]
For listRecurringCryptoMarkets, use the RecurringCryptoDuration values PT5M, PT15M, PT1H, and P1D. Use these same values with venue event discovery: 
const { data: events } = await client.getVenueEvents({
  status: ["open"],
  recurrence: ["PT5M", "PT15M", "PT1H"],
  limit: 50,
});
There is no recurrence-cadence catalog endpoint. If your integration previously expected a dynamic cadence list, read RECURRENCE_CADENCES from the SDK or use the enum shown in the API reference. Use the literal null only when filtering venue events with no recurring schedule.

​
1. Create the client

import { createAggClient } from "@agg-build/sdk";

const client = createAggClient({
  baseUrl: "https://api.agg.market",
  appId: "your-app-id",
});

​
2. List recurring crypto windows

listRecurringCryptoMarkets groups venue markets by asset, quote asset, duration, and window. Use it for crypto-specific market views where the user expects “current BTC 15m”, “current ETH 1h”, or similar rows. 
const windows = await client.listRecurringCryptoMarkets({
  assets: ["BTC", "ETH"],
  durations: ["PT15M", "PT1H"],
  window: "current",
  status: ["open"],
  includeDirectVenueMarkets: true,
});
Each returned window includes:
  • asset, quoteAsset, duration, windowStart, and windowEnd
  • markets[], one item per venue market in that window
  • per-market outcomes[] with market odds such as midpoint, bestBid, and bestAsk
  • per-market resolution, which can be passed back when polling reference prices

​
3. Poll reference prices

Use getCryptoReferencePrices with the windows or markets returned by discovery. The SDK will build the correct target payload for each venue market. 
const prices = await client.getCryptoReferencePrices({
  windowMarkets: windows.data,
});

for (const row of prices.data) {
  if (row.error) {
    console.warn(row.venueMarketId, row.error.code, row.error.message);
    continue;
  }

  console.log(row.venueMarketId, {
    asset: row.asset,
    price: row.normalized,
    fetchedAt: row.fetchedAt,
    ageMs: row.ageMs,
  });
}
The response includes softRefreshMs and hardMaxAgeMs. Use softRefreshMs as your normal poll interval for active views. Treat any row with error, stale: true, or a null normalized price as unavailable for display. 
async function pollReferencePrices() {
  const response = await client.getCryptoReferencePrices({ windowMarkets: windows.data });

  renderReferencePrices(response.data);

  window.setTimeout(pollReferencePrices, response.softRefreshMs);
}

void pollReferencePrices();

​
4. Match prices back to markets

Reference-price rows include the same venue-facing identifiers you already have from discovery. Index by venueMarketId for normal UI work. 
const byVenueMarketId = new Map(
  prices.data
    .filter((row) => !row.error && row.venueMarketId)
    .map((row) => [row.venueMarketId!, row]),
);

for (const windowMarket of windows.data) {
  for (const market of windowMarket.markets) {
    const reference = byVenueMarketId.get(market.venueMarketId);

    console.log({
      venue: market.venue,
      question: market.question,
      underlying: reference?.normalized ?? null,
      upMidpoint: market.outcomes.find((o) => o.label.toLowerCase() === "up")?.midpoint,
      downMidpoint: market.outcomes.find((o) => o.label.toLowerCase() === "down")?.midpoint,
    });
  }
}

​
API reference

Use the generated API Reference for request parameters, response schemas, and try-it-out examples:
Use caseAPI Reference
Discover recurring crypto windowsList recurring crypto window markets
Poll current underlying pricesGet live crypto reference prices
Browse venue events by recurrenceList venue events

​
Trading behavior

Recurring crypto discovery can include venue markets that are useful for display but not valid inputs to AGG smart order routing. Check these fields before enabling trade controls:
  • market.routeable
  • market.splitOrdersAllowed
  • outcome.routeable
  • outcome.splitOrdersAllowed
If routeable is false, do not pass that market to smart routing. If splitOrdersAllowed is false, do not split an order across venues for that market.

​
Integration notes

  • Reference prices are USD-only (quoteAsset: "USD") and are separate from prediction-market odds.
  • listRecurringCryptoMarkets supports deterministic crypto durations: PT5M, PT15M, PT1H, and P1D.
  • getCryptoReferencePrices accepts up to 100 targets. For active views, pass the visible windows or venue market ids rather than polling every discovered market.
  • Prefer getCryptoReferencePrices for live reference-price polling. The discovery endpoint can include reference prices, but the dedicated polling endpoint is built for fresh active views.
  • Treat rows with error, stale: true, or normalized: null as unavailable for display.
  • source.confidence can be verified, inferred, or missing. Show low-confidence or missing sources conservatively in production trading experiences.
  1. Call listRecurringCryptoMarkets for the current window and render the market cards.
  2. Call getCryptoReferencePrices for the visible windows.
  3. Display market odds and reference prices separately.
  4. Poll reference prices using softRefreshMs while the view is visible.
  5. Stop polling when the user leaves the view or the window status is no longer open.

​
FAQ

​
Are reference prices the same as market prices?

No. Reference prices are underlying crypto prices, such as BTC/USD or ETH/USD. Market prices are the prediction market odds for outcomes such as Up or Down.

​
Which crypto windows are supported?

The recurring crypto endpoint supports PT5M, PT15M, PT1H, and P1D. Venue event discovery can still filter broader recurrence cadences, but this crypto-specific endpoint is intentionally scoped to deterministic recurring crypto windows.

​
What should I do when a reference price is stale or unavailable?

Do not render it as a current price. Hide it, show an unavailable state, or keep the last accepted value visually distinct from live data. Always read error, stale, ageMs, and normalized before displaying a reference price.

Canonical Market Key

Use aggKey to identify the same market across venues.

Real-Time Orderbook

Stream live orderbook changes for tradable venue markets.