API reference#

Base URL: https://uselayer.sh. All responses are JSON.

Authentication#

Every endpoint except /v0/health needs a key from your dashboard:

authorization: Bearer lyr_your_key

x-api-key: lyr_your_key also works. Each key allows 60 requests per minute.

No key? Agents can pay for each call in USDC on Base instead: see Pay per call (x402).

Every endpoint and its inputs as an OpenAPI 3.1 file, for a coding agent or a client generator: /v0/openapi.json.

GET/v0/matches#

Every live match, soonest event first (by day, then by Kalshi's event time within the day, so 15-minute crypto windows lead their day). Without from, a match whose event ended over 12 hours ago is left out, even though both venues still have it open: a game that was never played or is waiting on a result, an election not yet certified. Send from with a past day to see those. Use it to discover what Layer can answer. For example, one weekend's NFL matches: ?category=sports&q=nfl&from=<Friday>&to=<Sunday>, with the dates as YYYY-MM-DD. A filter it can't read, such as from=Oct 5, returns 400 bad_request.

Response

Live prices#

Every account gets each match's live prices and best trade, read from both venues when you ask. So do GET /v0/match and POST /v0/match. Send prices=false (in the body for POST /v0/match: "prices": false) to skip them for a faster answer. A settled match has none. To trade, your code still reads order books and places orders with your own venue keys: the Python SDK does it for you.

Want live order books? For NBA, NFL, NHL and NCAAF game winners on Kalshi and Polymarket US, the Stream (Beta) pushes each change to the best prices over a WebSocket. For other markets, Layer doesn't stream books yet. If you'd use every venue's full order book and each change to it, over one WebSocket in one format, email david@uselayer.sh and say what language your bot is written in. Other ideas we're weighing are on Feature requests.

Hyperliquid matches get prices.hyperliquid but best_trade: null: Layer doesn't work out Hyperliquid's fees yet. Novig matches get prices.novig and a best_trade with a novig leg. Novig charges takers 0.06 × price × (1 − price) per contract: on a game line only once the game has started, so a trade before the game has no Novig fee, and on a season future always. If Layer can't read the market's fee or whether its game has started, best_trade is null. Novig's book holds only bids, so the ask on an outcome is 1 minus the best bid on the other outcome; sizes are in $1 contracts, like Kalshi's (one Novig contract pays 1¢).

Hyperliquid. venue=hyperliquid covers games (winners, soccer results with each team and the draw, a game's totals and spreads), season winners, crypto prices at a set time and IPO dates. There are no player props. If a venue's matches are ever switched off, asking for them here, on /v0/match or on /v0/settlements answers 403 venue_not_served. See How matching works.

Novig. venue=novig covers sports only: game lines (moneylines, spreads, totals and soccer's three-way result, each team and the draw) and season futures (champions, conference and division winners, playoff qualifiers), each team its own contract. There are no player props or half-game lines. If Novig's matches are ever switched off, asking for them here, on /v0/match or on /v0/settlements answers 403 venue_not_served. See How matching works.

GET/v0/match#

The twin of one market on the other venue.

From one Polymarket to the other. Layer pairs each Polymarket, Hyperliquid and Novig with Kalshi, not with each other, so there's no direct lookup from a polymarket.com market to its Polymarket US twin (or back). It takes two steps, through Kalshi:

# 1. The polymarket.com market's Kalshi match: matched_market.market_id is the Kalshi ticker
curl -H "Authorization: Bearer $LAYER_API_KEY" "https://uselayer.sh/v0/match?venue=polymarket&market_id=<conditionId>"
# 2. That Kalshi market's twin on Polymarket US
curl -H "Authorization: Bearer $LAYER_API_KEY" "https://uselayer.sh/v0/match?venue=kalshi&market_id=<matched_market.market_id>&with=polymarket_us"

If step 1 has no match, there's no Polymarket US twin to find either. Swap the venues to go from Polymarket US to polymarket.com (with=polymarket in step 2).

Match found

No match — matched_market is null and reason says why. source_market is still the market you asked about, or null when Layer doesn't know the id or can't tell which side you mean (specify_outcome).

Market object#

A market object carries ids and links, not the venue's own wording. For a market's title, question, times and settlement sources, read it from the venue with its market_id, on your machine.

GET/v0/settlements#

How each match settled on both venues, and whether they agreed: Layer's track record, newest first. Only matches that were live in the API when they settled are listed. Use it to check a match after the fact, or to settle your own positions. For example, everything that settled since your last call: ?since=2026-10-01T12:00:00Z (pass the checked_at of your last answer).

To see the record for one kind of market, send series or category. A Kalshi series is one league and one market type, so ?series=KXNFLGAME is every NFL game-winner match, and the answer adds scope_totals: how many of those settled and how many agreed. For a whole league, every market type, send the Polymarket side's series instead: ?polymarket_series=nfl-2025 (Polymarket US's NFL series).

Response

Settlement object#

curl -H "Authorization: Bearer $LAYER_API_KEY" "https://uselayer.sh/v0/settlements?venue=polymarket_us&since=2026-10-01"

Layer's record on NFL game winners with Polymarket US:

curl -H "Authorization: Bearer $LAYER_API_KEY" "https://uselayer.sh/v0/settlements?venue=polymarket_us&series=KXNFLGAME&limit=1"

{
  "count": 1,
  "totals": { "settled": 4053, "agreed": 4052, "disagreed": 1, "edge_case": 0 },
  "scope_totals": { "settled": 2, "agreed": 2, "disagreed": 0, "edge_case": 0 },
  "settlements": [ { "kalshi": { "series": "KXNFLGAME", "...": "..." }, "polymarket_us": { "...": "..." }, "settlement": { "outcome": "agreed", "...": "..." } } ],
  "attribution": "...",
  "checked_at": "2026-10-02T18:00:00.000Z"
}

Layer's record on every NFL market type with polymarket.com (game winners, spreads, totals and player props), by its series name:

curl -H "Authorization: Bearer $LAYER_API_KEY" "https://uselayer.sh/v0/settlements?venue=polymarket&polymarket_series=nfl-2026&limit=1"

{ "count": 1, "totals": { "settled": 5405, "agreed": 5405, "disagreed": 0, "edge_case": 0 }, "scope_totals": { "settled": 294, "agreed": 294, "disagreed": 0, "edge_case": 0 }, "...": "..." }

POST/v0/match#

Look up many markets in one call: up to 50, from any venue, mixed freely. The whole call counts as one request against your key's 60 per minute.

curl -X POST -H "authorization: Bearer $LAYER_KEY" \
  -H "content-type: application/json" \
  -d '{"markets":[{"venue":"kalshi","market_id":"KXFEDDECISION-26OCT-C25"},{"venue":"polymarket","market_id":"afcq-ben-mau-2026-09-29-ben"}]}' \
  "https://uselayer.sh/v0/match"

Request body

Response

A market Layer doesn't know comes back as not_indexed in its place in results; it doesn't fail the call. The call fails with 400 bad_request if the body is malformed or an entry's with names a venue it can't, and detail names the entry (for example markets.3.venue). It also fails as a whole (403 venue_not_served or 503 venue_unavailable) when a venue it touches is switched off or its matches aren't served.

POST/v0/profit#

Is buying one side on each venue profitable once fees are paid? You send the prices; Layer applies each venue's official fee schedule. Buying YES on one venue and NO on the other, for the same matched outcome, pays exactly $1 per contract however it settles. So the trade is profitable when the two prices plus both fees come to less than $1 per contract.

The trade is Kalshi plus one other venue: send kalshi and exactly one of polymarket or polymarket_us. Hyperliquid and Novig aren't priced here yet.

curl -X POST -H "authorization: Bearer $LAYER_KEY" \
  -H "content-type: application/json" \
  -d '{"contracts":100,"kalshi":{"price":0.42},"polymarket":{"price":0.55,"fee_rate":0.05}}' \
  "https://uselayer.sh/v0/profit"

Request body

price is the price of the side you buy on that venue. Pass the YES price on one venue and the NO price on the other.

Response

{
  "contracts": 100,
  "kalshi": { "price": 0.42, "role": "taker", "cost": 42, "fee": 1.71, "fee_rate": 0.07, "fee_multiplier": 1, "fee_type": "quadratic" },
  "polymarket": { "price": 0.55, "role": "taker", "cost": 55, "fee": 1.2375, "fee_rate": 0.05, "exponent": 1 },
  "payout": 100,
  "spread": 0.03,
  "gross_profit": 3,
  "fees": 2.9475,
  "net_profit": 0.0525,
  "return_pct": 0.05,
  "profitable": true
}

Return per day of capital held

A 2¢ edge that ties your money up for a month is a worse trade than the same edge paid out on Sunday. Send settles_at or days_held and the answer adds three fields:

{ "days_held": 4, "return_per_day_pct": 0.0131, "annualized_return_pct": 4.79 }

Both are worked out from the unrounded return, so compare opportunities by these rather than redoing the sum from the rounded return_pct. A losing trade gives negative numbers. For a very short hold the annualized figure gets large fast; treat it as a way to rank trades, not a promise you can repeat the trade every day. The money is only counted as tied up until settlement: the time a venue takes to pay out or to let you withdraw isn't included.

Send the match id instead of the fees

Pricing a match from /v0/matches? Send its Kalshi ticker as kalshi.market_id next to the two prices, and Layer fills in what it knows about the pair:

curl -X POST -H "authorization: Bearer $LAYER_KEY" \
  -H "content-type: application/json" \
  -d '{"contracts":100,"kalshi":{"price":0.42,"market_id":"KXFEDDECISION-26OCT-C25"},"polymarket":{"price":0.55}}' \
  "https://uselayer.sh/v0/profit"

• Kalshi: the series' fee_multiplier and fee_type.
• Polymarket: the market's own fee_rate and exponent (its feeSchedule).
• Polymarket US: the market's own fee_coefficient.
• days_held: from now until the match's expected payout: the later of the two venues' event times plus 6 hours, never past the later closing time, and at least 1 day.

The Polymarket leg you send picks the match: polymarket for the international one, polymarket_us for the US one. Anything you send yourself is used as you sent it, so you can still pass settles_at, days_held or any fee to override Layer's. The answer is the same as sending every value yourself, plus two fields:

{
  "match": {
    "kalshi": "KXFEDDECISION-26OCT-C25",
    "polymarket": "0x5f3c…",
    "expected_payout_at": "2026-10-28T18:00:00.000Z",
    "latest_payout_at": "2026-10-28T18:00:00.000Z"
  },
  "filled_in": ["kalshi.fee_multiplier", "kalshi.fee_type", "polymarket.fee_rate", "polymarket.exponent", "days_held"]
}

Layer reads the fees from each venue when you call, so the answer uses the fees in force right then. If the ticker has no match on the Polymarket you sent (live now, or live when it settled), the answer is 404 no_match, with the reason and how to check the ticker. If a venue doesn't answer when Layer asks for a fee, or Polymarket gives no fee schedule for the market and you sent no category, the answer is 503 fees_unavailable. Try again, or send that fee yourself. If Polymarket's fee can't be read and you sent category, Layer uses the category's rate and leaves polymarket.fee_rate out of filled_in.

How fees are worked out

• Kalshi: multiplier × rate × contracts × price × (1 − price), rounded up to the next cent. The rate is 0.07 for takers. Makers pay 0.0175, or 0.035 on combo series, but only on series whose fee_type includes maker fees. This follows Kalshi's fee schedule and matches its published fee table. Members whose balance is kept to $0.0001 may pay up to 1¢ less per order.
• Polymarket: contracts × fee_rate × (price × (1 − price))^exponent, rounded to 5 decimal places, takers only (Polymarket's fees).
• Polymarket US: fee_coefficient × contracts × price × (1 − price), rounded to the nearest cent with ties to even. Since 2026-11-06 at 1 PM ET the taker coefficient is tiered by the taker's trailing 30-day volume: 0.095 under $10,000, 0.085 to $50,000, 0.075 to $250,000 and 0.0695 above. Polymarket US's markets report 0.095, so Layer prices at that unless you send your own fee_coefficient. Makers get a rebate of 0.0125 × contracts × price × (1 − price), shown as a negative fee, until 2026-10-19. From then on Polymarket US pays a maker rebate only to makers with $10M or more of maker volume the month before, so Layer shows no rebate. This follows Polymarket US's fee schedule and matches its published 100-lot table. Its volume rebates, paid weekly, aren't included.

You send the prices, so no venue data is served: /v0/profit keeps working when a venue's data is switched off (see Errors). With kalshi.market_id it reads the match, so it's paused like /v0/match.

The answer assumes each order fills in full at the price you send, as a single order. It leaves out deposit and withdrawal costs, rebates, and any price movement while you trade. Fees change: if a venue's schedule differs from this, the venue's schedule wins.

POST/v0/size#

How much of a gap can you actually trade? The best prices often have only a few dollars behind them. You send the order book for the side you'd buy on each venue, and the smallest profit per contract you'll accept. Layer walks both books from the best price down and returns the largest size that still clears it after both venues' fees, your average price on each venue, and the slippage against the best price.

The trade is Kalshi plus one other venue, as in /v0/profit: send kalshi and exactly one of polymarket or polymarket_us. Hyperliquid and Novig aren't sized here yet.

curl -X POST -H "authorization: Bearer $LAYER_KEY" \
  -H "content-type: application/json" \
  -d '{"min_edge":0.01,"kalshi":{"asks":[{"price":0.42,"size":100},{"price":0.43,"size":300}]},"polymarket_us":{"asks":[{"price":0.52,"size":150},{"price":0.55,"size":500}]}}' \
  "https://uselayer.sh/v0/size"

Request body

Send the asks for the side you'd buy: YES on one venue and NO on the other. Where a venue lists only bids, turn them round: a bid of b for YES is an ask of 1 − b for NO, with the same size. Kalshi's order book (GET /markets/{ticker}/orderbook) lists YES bids and NO bids, so Kalshi's YES asks are 1 − each NO bid.

Response

{
  "contracts": 100,
  "limited_by": "min_edge",
  "min_edge": 0.01,
  "edge_at_best": 0.019236,
  "edge_at_last": 0.019236,
  "kalshi": {
    "best_price": 0.42, "average_price": 0.42, "slippage": 0, "slippage_cost": 0,
    "cost": 42, "fee": 1.71, "fee_rate": 0.07, "fee_multiplier": 1,
    "fills": [{ "price": 0.42, "contracts": 100, "cost": 42, "fee": 1.71 }]
  },
  "polymarket_us": {
    "best_price": 0.52, "average_price": 0.52, "slippage": 0, "slippage_cost": 0,
    "cost": 52, "fee": 2.37, "fee_coefficient": 0.095,
    "fills": [{ "price": 0.52, "contracts": 100, "cost": 52, "fee": 2.37 }]
  },
  "payout": 100,
  "cost": 94,
  "fees": 4.08,
  "slippage_cost": 0,
  "net_profit": 1.92,
  "net_profit_per_contract": 0.0192,
  "return_pct": 1.96,
  "profitable": true
}

Here the next Kalshi level (43¢) would earn only 0.91¢ a contract, below the 1¢ asked for, so the answer stops at 100. Leave min_edge out and it takes 50 more at 43¢: 150 contracts, $0.50 of slippage on Kalshi, $2.37 net.

How the size is worked out

• Layer pairs the cheapest remaining level on each venue and asks whether a contract there earns at least min_edge (and more than 0) after both taker fees. If it does, it takes as many as both levels have; if not, it stops. Books only get worse further down, so the first pair that fails ends the walk.
• That decision uses the edge before rounding. The totals then bill each fill (each level) the way the venue does, with its rounding (see How fees are worked out above). So net_profit can differ from the edges by a cent or two, mostly from Kalshi rounding each fill up to the cent.
• The answer is in whole contracts, so both legs pay out the same. A fractional level on either venue can be used in part.
• Every order is priced as a taker: walking the book means your order fills against it.

It's a snapshot: the answer is only as good as the books you send, and books move while you trade. It assumes each level fills in full for you, ahead of anyone else. You send the books, so no venue data is served: /v0/size keeps working when a venue's data is switched off.

GET/v0/quote#

How much of a matched market can you trade right now? Send a Kalshi ticker. Layer reads the full order book on both venues, tries the trade both ways round (Kalshi YES with Polymarket NO, and the reverse), and returns the better one: the most contracts that still clear min_edge after both venues' taker fees. It's POST /v0/size without having to fetch and send the books. Kalshi with Polymarket US by default, or polymarket.com with venue=polymarket.

curl -H "Authorization: Bearer $LAYER_API_KEY" "https://uselayer.sh/v0/quote?market_id=<kalshi.market_id>&min_edge=0.01"

Query parameters

Response

The fields of POST /v0/size, without the price-by-price fills, plus:

contracts: 0 is a normal answer: there's nothing to trade at your min_edge right now.

Errors: 404 no_match, 422 match_settled, 422 market_not_open (a market is closed or halted), 503 books_unavailable (a venue didn't answer), 503 fees_unavailable (polymarket.com gave no fee schedule), and the same 503 venue_unavailable and 403 venue_not_served as /v0/match.

It's a snapshot and doesn't promise a fill: books move while you trade, and if only one order fills you're left holding one side. It's priced as a taker on both venues.

GET/v0/sports/spreads#

Beta. The spread on every NBA, NFL, NHL and college football game that's live or starts within the next 24 hours, matched between Kalshi and Polymarket US. Only game winners matched as identical are included. Each game is priced the way GET /v0/quote prices a match: Layer reads both venues' books, tries both teams both ways round (Kalshi YES with Polymarket US NO, and the reverse), and keeps the trade closest to a profit after both venues' taker fees. Games are sorted by edge_cents, highest first, so the list isn't empty when nothing is profitable.

curl -H "Authorization: Bearer $LAYER_API_KEY" "https://uselayer.sh/v0/sports/spreads?league=nba"

Query parameters

Response

{
  "as_of": "2026-11-10T22:00:00.123Z",
  "games": [{
    "event_id": "KXNBAGAME-26NOV10MIAUTA",
    "market_id": null,
    "league": "nba",
    "title": "Miami vs Utah — MIA vs UTA (Nov 10)",
    "question": "Miami vs Utah: Miami wins",
    "starts_at": "2026-11-11T02:00:00.000Z",
    "status": "upcoming",
    "kalshi": { "ticker": "KXNBAGAME-26NOV10MIAUTA-MIA", "yes_bid": 0.74, "yes_ask": 0.75, "ask_size": 25910.93, "as_of": "2026-11-10T21:59:58.000Z" },
    "polymarket_us": { "slug": "aec-nba-mia-uta-2026-11-10:long", "yes_bid": 0.75, "yes_ask": 0.76, "ask_size": 354725.36, "as_of": "2026-11-10T21:59:41.000Z" },
    "direction": "kalshi_yes_pmus_no",
    "edge_cents": -3.09,
    "arbitrage": false,
    "contracts": 0,
    "net_dollars": 0
  }]
}

Books are read at most every 5 seconds per game, so as_of can be up to 5 seconds old. Spreads that clear fees often close quickly, so a profitable row may be gone by the time you read it.

Errors: 400 for an unknown league, 503 books_unavailable (a venue didn't answer), and the same 503 venue_unavailable and 403 venue_not_served as /v0/match.

It's a snapshot and doesn't promise a fill, as with /v0/quote.

GET/v0/sports/lead#

Beta. Over the last days days Layer has processed: for Kalshi and Polymarket US game winners in the NBA, NFL, NHL and college football, which venue moved first, how often the other followed, and how long it took, plus how often spreads that cleared both venues' fees appeared and how long they stayed open. Computed each night from Layer's recordings of both venues' order books.

curl -H "Authorization: Bearer $LAYER_API_KEY" "https://uselayer.sh/v0/sports/lead?league=nba&days=7"

Fields and definitions: Sports spreads and lag. Errors: 400 for an unknown league or a days outside 1 to 30.

GET/v0/sports/events#

Beta. One day's recorded spreads and moves, one by one with their times, to line up against your own bot's logs.

curl -H "Authorization: Bearer $LAYER_API_KEY" "https://uselayer.sh/v0/sports/events?league=nba&date=2026-11-09"

status says whether Layer has processed that day (done); before then the lists are empty. Fields: Sports spreads and lag. Errors: 400 for an unknown league or a missing or malformed date.

Webhooks#

Instead of polling, register an https URL and Layer POSTs to it when a match changes:

Each event is one line of a game, like one row of /v0/matches. Events go out within about a minute of Layer seeing the change. Layer looks for new matches every hour and for settlements every 6 hours, so that's how fresh they are. Crypto windows are faster: Layer checks for them every minute, and a new 15-minute window's match.live usually goes out about 30 seconds after the window opens (see Crypto windows).

POST /v0/webhooks#

Register an endpoint. You can have up to 5.

curl -X POST https://uselayer.sh/v0/webhooks \
  -H "Authorization: Bearer $LAYER_API_KEY" -H "content-type: application/json" \
  -d '{"url":"https://example.com/layer-webhook","venues":["polymarket_us"]}'

{
  "id": "whe_3f2a9c1d0b7e4a65",
  "url": "https://example.com/layer-webhook",
  "events": ["match.live", "match.pulled", "match.settled"],
  "venues": ["polymarket_us"],
  "description": null,
  "created_at": "2026-10-01T18:00:00.000Z",
  "secret": "whsec_…",
  "next": "POST /v0/webhooks/whe_3f2a9c1d0b7e4a65/test sends a signed test event to it now."
}

Save secret now. It's shown only in this answer, and you need it to check that a request came from Layer. To change it, delete the endpoint and register it again. An endpoint gets only events that happen after you register it.

GET /v0/webhooks#

Your endpoints, each with how its deliveries are going: delivered, pending (waiting for a retry) and failed (gave up) counts, and last_attempt (at, status, error, ok), as { "endpoints": [ … ] }.

GET /v0/webhooks/{id}#

One endpoint and its last 20 deliveries, newest first: event_id, type, test, status (pending, delivered or failed), attempts, last_attempt_at, last_status (your server's HTTP status, or null if it didn't answer), last_error and next_attempt_at.

DELETE /v0/webhooks/{id}#

Stops sending to it. Deliveries still waiting for a retry are dropped. Answers { "deleted": true, "id": "…" }.

POST /v0/webhooks/{id}/test#

Sends one signed test event now and answers with how your server replied: delivered, status, error, ms and sent (the exact payload). With no body it sends webhook.test. With {"type":"match.live"} (or match.pulled, match.settled) it sends a real recent example of that event from your endpoint's venues, so you can test your handler on the real shape. Test payloads have "test": true and aren't retried.

curl -X POST https://uselayer.sh/v0/webhooks/whe_3f2a9c1d0b7e4a65/test \
  -H "Authorization: Bearer $LAYER_API_KEY" -d '{"type":"match.settled"}'

Payload#

{
  "id": "evt_1042",
  "type": "match.live",
  "timestamp": "2026-10-01T18:30:12.000Z",
  "data": {
    "kalshi": { "venue": "kalshi", "market_id": "KXNFLGAME-26OCT04DALHOU-DAL", "…": "…" },
    "polymarket_us": { "venue": "polymarket_us", "market_id": "nfl-dal-hou-2026-10-04:long", "…": "…" },
    "category": "sports",
    "tier": "auto_verified",
    "confidence": 0.97,
    "basis": "identical",
    "caveats": [],
    "caveat_notes": {}
  }
}

Checking the signature#

Layer signs every request the Standard Webhooks way, so its libraries verify it (npm install standardwebhooks, pip install standardwebhooks). Each request has three headers:

import { Webhook } from "standardwebhooks";

const wh = new Webhook(process.env.LAYER_WEBHOOK_SECRET); // whsec_…
// In your handler, with the raw request body as a string (not re-serialized JSON):
const event = wh.verify(rawBody, {
  "webhook-id": req.headers["webhook-id"],
  "webhook-timestamp": req.headers["webhook-timestamp"],
  "webhook-signature": req.headers["webhook-signature"],
}); // throws if the signature or timestamp is wrong

Answering and retries#

Answer with any 2xx within 10 seconds, and do slow work after you answer. Anything else (another status, a redirect, a timeout, or no answer) is retried after 1 minute, 5 minutes, 30 minutes, 2 hours, 5 hours, 10 hours and 10 hours, then Layer gives up on that event. That's 8 attempts over about 28 hours, and GET /v0/webhooks/{id} shows each one.

Events aren't sent while a venue is switched off or its matches aren't served (venue_unavailable, venue_not_served below). They also aren't sent to an account with no active API key.

GET/v0/health#

No key needed. Is the API up and can it reach its database?

{
  "ok": true,
  "database": { "reachable": true, "ms": 62 },
  "venues": {
    "kalshi": { "open_events": 12587, "open_markets": 125458, "last_pull": "…" },
    "polymarket": { "open_events": 42935, "open_markets": 364647, "last_pull": "…" },
    "polymarket_us": { "open_events": 4032, "open_markets": 65561, "last_pull": "…" },
    "hyperliquid": { "open_events": 73, "open_markets": 167, "last_pull": "…" },
    "novig": { "open_events": 1154, "open_markets": 18405, "last_pull": "…" }
  },
  "live_market_pairs": 14,
  "live_market_pairs_by_venue": { "polymarket": 14, "polymarket_us": 9 },
  "checked_at": "…"
}

venues lists every venue Layer pulls, Hyperliquid's outcome markets and Novig's game lines included (for Novig, open_events counts one per game and kind of line). live_market_pairs counts live matches with polymarket.com; live_market_pairs_by_venue counts them for each Polymarket, and doesn't count Hyperliquid or Novig yet.

Errors#

Every 400 says what's wrong and how to fix it:

{
  "error": "bad_request",
  "detail": "body: send settles_at or days_held, not both",
  "hint": "Send one or the other: \"settles_at\": \"2026-10-14\" if you know when the market settles, or \"days_held\": 4 if you know how many days your money is tied up.",
  "docs": "https://uselayer.sh/docs/api"
}

Using Layer data#

Every /v0/matches, /v0/match and /v0/settlements answer includes an attribution line. Layer serves which markets are the same bet and how matches settled. Live prices, order books and orders go straight between your code and each venue, under your own account with that venue, and trading happens on each venue. When you show a market to your users, credit the venue and link to its url. Use Layer data inside your own product; don't republish it as a standalone feed or aggregator. The full terms are at /terms.