{"id":4132,"date":"2026-09-20T10:00:00","date_gmt":"2026-09-20T10:00:00","guid":{"rendered":"https:\/\/oddspapi.io\/blog\/?p=4132"},"modified":"2026-09-14T14:34:24","modified_gmt":"2026-09-14T14:34:24","slug":"odds-api-market-makers-size-at-price","status":"publish","type":"post","link":"https:\/\/oddspapi.io\/blog\/odds-api-market-makers-size-at-price\/","title":{"rendered":"Odds API for Market Makers: Size Moves Twice as Often as Price"},"content":{"rendered":"

A Price Without a Size Is Not a Quote<\/h2>\n

Every odds API will sell you a price. Open the docs of any feed vendor and you get decimal odds, American odds, fractional odds, a timestamp if you are lucky. For a bettor that is enough. For anyone quoting two-sided markets it is half the payload.<\/p>\n

A market maker cannot act on 3.571 alone. The question is whether 3.571 stands in front of $133 or $16,453, because one of those is a quote and the other is a rounding error. That number exists in the OddsPapi feed. It is called limit<\/code>, it is normalised across every venue that publishes one, and this post shows you how to pull it, how to read the depth ladder underneath it, and what it does that a price column cannot.<\/p>\n

Everything below was measured against the live API on 14 September 2026, on a single Premier League fixture: Leeds United against Newcastle United, id1000001772221262<\/code>, kick-off 19:00Z. One unfiltered \/odds<\/code> call on that fixture returned 286 bookmakers and 62.7 MB<\/strong>. Every number in this post comes out of that call or a second one ten minutes later.<\/p>\n

The Headline: Size Moves Twice as Often as Price<\/h2>\n

Two snapshots of the same fixture, ten minutes apart, 14:22Z and 14:32Z. Seventy-five fully sized legs of the 1X2 market appear in both. Here is what changed between them:<\/p>\n

\n\n\n\n\n\n\n\n
What moved<\/th>\nLegs<\/th>\nShare<\/th>\n<\/tr>\n<\/thead>\n
Price changed<\/td>\n14<\/td>\n19%<\/td>\n<\/tr>\n
Stake limit changed<\/td>\n27<\/td>\n36%<\/td>\n<\/tr>\n
Limit moved while the price held still<\/strong><\/td>\n13<\/strong><\/td>\n17%<\/strong><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/figure>\n

Read that last row again. On thirteen legs the price was byte-identical across both snapshots and the size behind it was not. A feed that ships prices alone reports nothing happened on those thirteen legs. Something very much happened.<\/p>\n

The sharpest example is Polymarket on the away participant. At 14:22Z it quoted 3.333 with 9,126<\/strong> behind it. At 14:32Z it quoted 3.333 with 1,022<\/strong> behind it. The price did not move a tick. Eighty-nine percent of the size drained out from under it. ProphetX did the same thing on the same leg, 2,264 down to 695, price unchanged at 3.20.<\/p>\n

It runs the other way too. Polymarket’s draw leg went 5,883 to 16,453 and Kalshi’s went 9,387 to 16,659, both at a frozen price. Size is the fast variable on an exchange board. Price is the slow one.<\/p>\n

Why Line Shopping Alone Does Not Survive This<\/h2>\n

The standard pattern is to pull every book, sort by price and take the best number. On this fixture that pattern hands you Polymarket at 3.333 on the away participant at 14:32Z, which is the best available price, sitting on 1,022 of size. Meanwhile Betfair Exchange offers 3.20 on 4,205. If you need to move 4,000 the worse price is the only real one.<\/p>\n

This is where a market-making read diverges from a line shopping read<\/a>. Best price is a scalar. Best executable price is a function of the size you need to move.<\/p>\n

\n\n\n\n\n\n\n\n\n\n\n
What you need<\/th>\nBuilding it yourself<\/th>\nOddsPapi<\/th>\n<\/tr>\n<\/thead>\n
Stake limit per price<\/td>\nScrape each book’s bet slip, different rules per venue<\/td>\nlimit<\/code>, normalised across every book that publishes one<\/td>\n<\/tr>\n
Order book depth<\/td>\nIntegrate Betfair, Polymarket, Kalshi and ProphetX APIs separately<\/td>\nexchangeMeta<\/code> back and lay ladders in the same payload<\/td>\n<\/tr>\n
Sharp reference price<\/td>\nBuy a second feed for Pinnacle<\/td>\nPinnacle and SBOBET alongside the soft books<\/td>\n<\/tr>\n
Quote age you can verify<\/td>\nTrust the vendor’s marketing number<\/td>\nTwo timestamps on every price, subtract them yourself<\/td>\n<\/tr>\n
Fill auditing after the fact<\/td>\nBuild and run your own tick database<\/td>\nFree \/historical-odds<\/code> price timelines on every tier<\/td>\n<\/tr>\n
Push rather than poll<\/td>\nWrite a poller, miss every in-play move<\/td>\nWebSocket gateway at wss:\/\/v5.oddspapi.io\/ws<\/code><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/figure>\n

Step 1: Find the Books That Publish Size<\/h2>\n

Not every book tells you what it will take. The ones that do are the ones you price against: the sharp books, the exchanges and the prediction markets. Start by splitting the board.<\/p>\n

import os, time, requests\n\nAPI_KEY  = os.environ[\"ODDSPAPI_API_KEY\"]\nBASE_URL = \"https:\/\/api.oddspapi.io\/v4\"\n\ndef get_board(fixture_id, bookmakers=None):\n    \"\"\"One \/odds call. Pass bookmakers to keep the payload small.\"\"\"\n    params = {\"apiKey\": API_KEY, \"fixtureId\": fixture_id}\n    if bookmakers:\n        params[\"bookmakers\"] = \",\".join(bookmakers)\n    r = requests.get(f\"{BASE_URL}\/odds\", params=params, timeout=300)\n    if r.status_code == 429:\n        time.sleep(r.json()[\"error\"][\"retryMs\"] \/ 1000 + 0.5)\n        return get_board(fixture_id, bookmakers)\n    r.raise_for_status()\n    return r.json()[\"bookmakerOdds\"]\n\ndef walk_prices(board):\n    \"\"\"bookmakerOdds -> markets -> outcomes -> players -> the price object.\"\"\"\n    for slug, book in board.items():\n        for market_id, market in (book.get(\"markets\") or {}).items():\n            for outcome_id, outcome in (market.get(\"outcomes\") or {}).items():\n                for player_id, price in (outcome.get(\"players\") or {}).items():\n                    yield slug, market_id, outcome_id, price\n\ndef books_with_limits(board):\n    sized, unsized = [], []\n    for slug, book in board.items():\n        has = any(p.get(\"limit\") is not None\n                  for _, _, _, p in walk_prices({slug: book}))\n        (sized if has else unsized).append(slug)\n    return sorted(sized), sorted(unsized)\n\nFIXTURE = \"id1000001772221262\"          # Leeds United v Newcastle United\nboard = get_board(FIXTURE)\nsized, unsized = books_with_limits(board)\nprint(f\"bookmakers on fixture : {len(board)}\")\nprint(f\"publish a stake limit : {len(sized)}\")\nprint(f\"publish no limit      : {len(unsized)}\")<\/code><\/pre>\n
bookmakers on fixture : 286\npublish a stake limit : 29\npublish no limit      : 257<\/code><\/pre>\n
Twenty-nine books, and the membership is the interesting part. The whole Pinnacle network is in. The whole Betfair network is in. Every exchange and prediction market on the fixture is in: Kalshi, Polymarket, Novig US, Prophet Exchange, SX Bet and 4casters. FanDuel is partial, carrying a limit on 179 of its 851 prices. Bet365 and DraftKings carry none.<\/p>\n
That is the correct shape for this field. A retail book does not publish what it will take because its answer depends on who is asking. A sharp book publishes it because the number is the product.<\/p>\n
Step 2: Read Every Ladder With One Function<\/h2>\n
Under the top-of-book price, every exchange and prediction market ships a depth ladder in exchangeMeta<\/code>. Different venues built their books differently, so the field arrives in more than one arrangement. Write the reader once and you never think about it again.<\/p>\n
def read_ladder(price):\n    \"\"\"Return (back, lay) as lists of {price, size}, best price first.\n\n    Handles every exchangeMeta arrangement in the v4 feed:\n      back \/ lay              with {cents, limit, price, size}   prediction markets\n      back \/ lay              with {cents, limit, price}         prophetx, no size key\n      availableToBack \/ Lay   with {price, size}                 betfair network\n      null                    no ladder on this venue\n    \"\"\"\n    meta = price.get(\"exchangeMeta\") or {}\n    if not isinstance(meta, dict):\n        return [], []\n\n    def rungs(*keys):\n        for key in keys:\n            levels = meta.get(key)\n            if isinstance(levels, list) and levels:\n                return [\n                    {\n                        \"price\": lv.get(\"price\"),\n                        # prophetx omits size, so fall back to limit\n                        \"size\": lv.get(\"size\", lv.get(\"limit\")),\n                    }\n                    for lv in levels if isinstance(lv, dict)\n                ]\n        return []\n\n    return rungs(\"back\", \"availableToBack\"), rungs(\"lay\", \"availableToLay\")<\/code><\/pre>\n
Three rules that will save you a debugging session. The ladder is live only<\/strong>: exchangeMeta<\/code> is null<\/code> on every historical snapshot, so for depth history you use the snapshot-level limit<\/code> instead. Rung lists are ordered best price first<\/strong>, and the top of the back ladder equals the outcome’s main price<\/code>. And tradedVolume<\/code> on the Betfair network arrives as an integer on some rungs and a float on others inside the same fixture, so type it loosely.<\/p>\n
Sportsbooks ship exchangeMeta: null<\/code>, which is correct and expected. They have no order book to expose. If you want the two-sided view on a retail book you build it from the opposing outcome, not from this field.<\/p>\n
Step 3: Rank the Board by Size Skew<\/h2>\n
Here is the measurement that changes how you read a board. Take every book quoting all three legs of the 1X2 with a live limit on each, then divide the widest leg by the thinnest.<\/p>\n
def sized_market(board, market_id, outcome_ids):\n    \"\"\"Books quoting every leg active, with a limit on each.\"\"\"\n    out = {}\n    for slug, book in board.items():\n        market = (book.get(\"markets\") or {}).get(market_id)\n        if not market:\n            continue\n        legs = {}\n        for outcome_id in outcome_ids:\n            outcome = (market.get(\"outcomes\") or {}).get(outcome_id) or {}\n            price = (outcome.get(\"players\") or {}).get(\"0\")\n            if not price or not price.get(\"active\") or price.get(\"limit\") is None:\n                legs = None\n                break\n            legs[outcome_id] = (price[\"price\"], float(price[\"limit\"]))\n        if legs and min(lim for _, lim in legs.values()) > 0:\n            out[slug] = legs\n    return out\n\ndef size_skew(legs):\n    \"\"\"Widest leg over thinnest. 1.0 means equal size on every outcome.\"\"\"\n    limits = [lim for _, lim in legs.values()]\n    return max(limits) \/ min(limits)\n\nMARKET, OUTCOMES = \"101\", [\"101\", \"102\", \"103\"]      # soccer 1X2 fulltime\nquotes = sized_market(board, MARKET, OUTCOMES)\n\nfor slug, legs in sorted(quotes.items(), key=lambda kv: -size_skew(kv[1])):\n    cells = \"  \".join(f\"{p} @ {lim:,.0f}\" for p, lim in legs.values())\n    print(f\"{slug:18}{size_skew(legs):>7.1f}x   {cells}\")<\/code><\/pre>\n
Twenty-five of the 286 books clear that filter. The 14:22Z snapshot ranks them like this:<\/p>\n
\n\n\n\n\n\n\n\n\n\n\n\n\n
Bookmaker<\/th>\nLeeds<\/th>\nDraw<\/th>\nNewcastle<\/th>\nSize skew<\/th>\n<\/tr>\n<\/thead>\n
sx.bet<\/td>\n2.353 @ 4,819<\/td>\n3.54 @ 114<\/td>\n3.226 @ 103<\/td>\n47.0x<\/td>\n<\/tr>\n
novig.us<\/td>\n2.353 @ 3,285<\/td>\n3.571 @ 133<\/td>\n3.226 @ 3,927<\/td>\n29.5x<\/td>\n<\/tr>\n
polymarket<\/td>\n2.381 @ 146,803<\/td>\n3.571 @ 5,883<\/td>\n3.333 @ 9,126<\/td>\n25.0x<\/td>\n<\/tr>\n
betfair-ex<\/td>\n2.38 @ 6,516<\/td>\n3.6 @ 17,357<\/td>\n3.25 @ 1,402<\/td>\n12.4x<\/td>\n<\/tr>\n
kalshi<\/td>\n2.381 @ 5,935<\/td>\n3.571 @ 9,387<\/td>\n3.226 @ 50,178<\/td>\n8.5x<\/td>\n<\/tr>\n
prophetx<\/td>\n2.38 @ 729<\/td>\n3.6 @ 301<\/td>\n3.2 @ 2,264<\/td>\n7.5x<\/td>\n<\/tr>\n
paddypower<\/td>\n2.30 @ 5,769<\/td>\n3.50 @ 3,000<\/td>\n3.25 @ 3,333<\/td>\n1.9x<\/td>\n<\/tr>\n
pinnacle<\/strong><\/td>\n2.34 @ 10,000<\/strong><\/td>\n3.50 @ 10,000<\/strong><\/td>\n3.17 @ 10,000<\/strong><\/td>\n1.0x<\/strong><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/figure>\n
Sort that table by price and the top six venues look like the same book. Every one of them quotes the home participant between 2.353 and 2.381. Sort by size and they are six different venues with six different appetites. Polymarket will take 146,803 on Leeds and 5,883 on the draw off the same screen.<\/p>\n
Pinnacle is the control, and it is worth saying why. A flat 10,000 across all three legs is what a book with a real risk desk looks like: it has a position it is comfortable with and it will take that position on any outcome. That symmetry is also why Pinnacle stays the de-vig anchor for consensus fair value<\/a>. Its 1X2 here runs a 2.85% overround, giving no-vig probabilities of 41.5% Leeds, 27.8% draw, 30.7% Newcastle.<\/p>\n
Step 4: Watch Size Move While Price Holds Still<\/h2>\n
Run the board twice and diff it. This is the loop that produced the headline table at the top of this post.<\/p>\n
def sized_legs(board, market_id, outcome_ids):\n    \"\"\"{(slug, outcome_id): (price, limit)} for every active, sized leg.\"\"\"\n    out = {}\n    for slug, legs in sized_market(board, market_id, outcome_ids).items():\n        for outcome_id, (price, limit) in legs.items():\n            out[(slug, outcome_id)] = (price, limit)\n    return out\n\nfirst  = sized_legs(get_board(FIXTURE), MARKET, OUTCOMES)\ntime.sleep(600)\nsecond = sized_legs(get_board(FIXTURE), MARKET, OUTCOMES)\n\nboth = set(first) & set(second)\nprice_moved = {k for k in both if first[k][0] != second[k][0]}\nlimit_moved = {k for k in both if first[k][1] != second[k][1]}\nsilent      = limit_moved - price_moved\n\nprint(f\"legs in both snapshots : {len(both)}\")\nprint(f\"price changed          : {len(price_moved)}\")\nprint(f\"limit changed          : {len(limit_moved)}\")\nprint(f\"limit moved, price did not : {len(silent)}\")\n\nfor key in sorted(silent, key=lambda k: second[k][1] \/ first[k][1])[:4]:\n    slug, outcome_id = key\n    print(f\"  {slug:14} outcome {outcome_id}  \"\n          f\"{first[key][1]:>10,.0f} -> {second[key][1]:>10,.0f}\")<\/code><\/pre>\n
legs in both snapshots : 75\nprice changed          : 14\nlimit changed          : 27\nlimit moved, price did not : 13\n  polymarket     outcome 103       9,126 ->      1,022\n  prophetx       outcome 103       2,264 ->        695\n  prophetx       outcome 101         729 ->        526\n  kalshi         outcome 103      50,178 ->     38,536<\/code><\/pre>\n
Ten minutes of a quiet pre-match board and a third of the sized legs repriced their size. If your signal is built on price deltas you saw four of those thirteen events, because four of them also happened to move a tick. You missed the other nine.<\/p>\n
This is the argument for the WebSocket gateway<\/a> rather than a poll loop. A ten minute poll interval caught the net change on this fixture. It did not catch the path. On the v5 gateway limit<\/code> changes arrive as ordinary odds updates on the odds channel, so every size move lands as its own message with its own cursor.<\/p>\n
Step 5: Audit the Quote Age Yourself<\/h2>\n
Every price carries two timestamps. bookmakerChangedAt<\/code> is the book’s own change time. changedAt<\/code> is when OddsPapi observed it. Subtract them and you have the observation delay on that specific quote, computed from the payload, needing nobody’s word for it.<\/p>\n
import statistics\nfrom datetime import datetime\n\ndef parse(stamp):\n    return datetime.fromisoformat(stamp.replace(\"Z\", \"+00:00\"))\n\ndef observation_delays(board, slug):\n    \"\"\"changedAt minus bookmakerChangedAt, per active price. Seconds.\"\"\"\n    delays = []\n    for _, _, _, price in walk_prices({slug: board[slug]}):\n        if not price.get(\"active\"):\n            continue\n        seen, moved = price.get(\"changedAt\"), price.get(\"bookmakerChangedAt\")\n        if seen and moved:\n            delays.append((parse(seen) - parse(moved)).total_seconds())\n    return delays\n\nfor slug in [\"sx.bet\", \"betfair-ex\", \"draftkings\", \"kalshi\", \"pinnacle\", \"polymarket\"]:\n    delays = observation_delays(board, slug)\n    if len(delays) >= 10:\n        print(f\"{slug:14}{len(delays):>6} prices   median {statistics.median(delays):.3f}s\")<\/code><\/pre>\n
sx.bet            34 prices   median 0.101s\nbetfair-ex       417 prices   median 0.122s\ndraftkings       568 prices   median 0.140s\nkalshi           117 prices   median 0.159s\npinnacle         135 prices   median 0.284s\npolymarket       154 prices   median 0.388s<\/code><\/pre>\n
Read the median, not the tail. This is a pre-match board, so the upper percentiles are dominated by rungs nobody has touched for hours rather than by slow delivery. Note also that 73 of the 286 books publish bookmakerChangedAt<\/code> on ten or more active prices<\/strong>, so this self-audit works on the books that timestamp themselves. For the rest you compare changedAt<\/code> against your own receipt time.<\/p>\n
If you want the vendor’s own figures rather than your own, the B2B documentation publishes per-book freshness bounds on GET \/bookmakers<\/code>: maxDelayLiveInSec<\/code>, maxDelayPregameInSec<\/code> and maxDelayPregameMainInSec<\/code>.<\/p>\n
One Trap Before You Build a Consensus<\/h2>\n
The board looks wider than it is. On this fixture 270 books quote a full active 1X2 and they collapse to 87 distinct price tuples<\/strong>, a 67.8% duplication rate. White-label platforms and crypto-casino groups share pricing engines, so a naive average weights one engine by however many skins it runs. The largest single group is 24 feeds quoting the identical 2.28 \/ 3.45 \/ 3.00.<\/p>\n
from collections import Counter\n\ndef price_tuples(board, market_id, outcome_ids):\n    tuples = {}\n    for slug, legs in sized_market(board, market_id, outcome_ids).items():\n        tuples[slug] = tuple(p for p, _ in legs.values())\n    return tuples\n\nall_quotes = {}\nfor slug, book in board.items():\n    market = (book.get(\"markets\") or {}).get(MARKET)\n    if not market:\n        continue\n    legs = []\n    for outcome_id in OUTCOMES:\n        outcome = (market.get(\"outcomes\") or {}).get(outcome_id) or {}\n        price = (outcome.get(\"players\") or {}).get(\"0\")\n        if not price or not price.get(\"active\"):\n            legs = None\n            break\n        legs.append(price[\"price\"])\n    if legs:\n        all_quotes[slug] = tuple(legs)\n\ngroups = Counter(all_quotes.values())\nprint(f\"books quoting a full active 1X2 : {len(all_quotes)}\")\nprint(f\"distinct price tuples           : {len(groups)}\")\nprint(f\"largest identical group         : {groups.most_common(1)[0][1]} feeds\")<\/code><\/pre>\n
books quoting a full active 1X2 : 270\ndistinct price tuples           : 87\nlargest identical group         : 24 feeds<\/code><\/pre>\n
Deduplicate on the price tuple before you average anything or quote a book count. The cloneOf<\/code> field on \/bookmakers<\/code> identifies the venue families it knows about, including the Betfair agent network and the Pinnacle network, but it is a venue relationship rather than a pricing-engine fingerprint. The tuple is what you actually care about.<\/p>\n
What This Post Does Not Cover<\/h2>\n
Three honest boundaries, because a pre-match snapshot is not a universal claim.<\/p>\n