{"id":3161,"date":"2026-08-04T10:00:00","date_gmt":"2026-08-04T10:00:00","guid":{"rendered":"https:\/\/oddspapi.io\/blog\/?p=3161"},"modified":"2026-07-28T18:32:54","modified_gmt":"2026-07-28T18:32:54","slug":"betting-limits-api-stake-sizing","status":"publish","type":"post","link":"https:\/\/oddspapi.io\/blog\/betting-limits-api-stake-sizing\/","title":{"rendered":"Betting Limits API: How Much Can You Actually Bet at the Best Price?"},"content":{"rendered":"

Your scanner just flagged a +3.2% edge. Congratulations. Now answer the question that actually decides whether this is a business or a hobby: how much can you get down at that price?<\/p>\n

Every odds API on the market will sell you the number. Almost none of them will tell you the size behind it. That gap is where most betting bots die. The model says stake $40,000, the book takes $375, and the spreadsheet that showed 8% ROI was describing a market that does not exist at your bet size.<\/p>\n

The syndicates understood this before anyone was writing Python. Zeljko Ranogajec’s operation was not built on picking more winners than everyone else. It was built on getting real money onto a number before that number moved, across dozens of accounts, in the markets where the books would take size. Bill Benter’s Hong Kong operation had the same shape. The edge was distribution as much as prediction.<\/p>\n

OddsPapi ships the size alongside the price. Every outcome in the live feed carries a limit<\/code> field, and every exchange carries a full back and lay ladder with the capital sitting at each level. This guide shows you how to read both, how to reverse-engineer the rule Pinnacle uses to set its limits, and how to work out what your edge is worth after you account for what you can actually fill.<\/p>\n

Every number below came off the live API on 28 July 2026, from a single MLB fixture: Miami Marlins at Philadelphia Phillies, fixtureId<\/code> id1300010963301639<\/code>.<\/p>\n

The number your odds feed is missing<\/h2>\n
\n\n\n\n\n\n\n\n\n\n
Question<\/th>\nScraping or a price-only API<\/th>\nOddsPapi<\/th>\n<\/tr>\n<\/thead>\n
What is the best price?<\/td>\nYes<\/td>\nYes, across 350+ books<\/td>\n<\/tr>\n
How much will they take at it?<\/td>\nPlace the bet and find out<\/td>\nlimit<\/code> on every outcome<\/td>\n<\/tr>\n
What sits behind the top of book?<\/td>\nNo<\/td>\nexchangeMeta<\/code> back and lay ladder<\/td>\n<\/tr>\n
Did the limit move overnight?<\/td>\nNo<\/td>\nFree \/historical-odds<\/code> snapshots carry limits<\/td>\n<\/tr>\n
Cost<\/td>\nEnterprise contract or a scraper you maintain<\/td>\nFree tier<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/figure>\n

Who publishes a limit and who does not<\/h2>\n

Thirteen bookmakers quoted the moneyline on our Marlins fixture. Three of them told us how much they would take.<\/p>\n

\n\n\n\n\n\n\n\n\n\n\n\n
Book<\/th>\nPrice (Miami)<\/th>\nLimit<\/th>\n<\/tr>\n<\/thead>\n
kalshi<\/td>\n1.961<\/td>\n$391,922<\/td>\n<\/tr>\n
polymarket<\/td>\n1.961<\/td>\n$77,130<\/td>\n<\/tr>\n
pinnacle<\/td>\n1.925<\/td>\n$8,108<\/td>\n<\/tr>\n
fanduel<\/td>\n1.91<\/td>\nnull<\/code><\/td>\n<\/tr>\n
circasports<\/td>\n1.909<\/td>\nnull<\/code><\/td>\n<\/tr>\n
draftkings<\/td>\n1.89<\/td>\nnull<\/code><\/td>\n<\/tr>\n
betmgm, borgata, caesars, williamhill, hardrockbet, pointsbet.com.au<\/td>\n1.87<\/td>\nnull<\/code><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/figure>\n

The pattern is not random. Pinnacle and the exchanges publish a limit because their limit is a property of the market. They price for anyone and they cap by risk, so the number is public and identical for every account. The US retail books return null<\/code> because their limit is a property of you<\/em>. There is no market-wide max bet at DraftKings. There is a max bet for your account, set by how much you have won, and they are not putting that in a feed.<\/p>\n

That asymmetry is worth internalising before you build anything. On the sharp side, the API tells you the truth. On the soft side, you have to model your own account history and accept that the ceiling drops as you win.<\/p>\n

One housekeeping note on that table: six books quoting 1.87 is six slugs, not six independent opinions. betmgm<\/code> and borgata<\/code> run the same pricing, as do caesars<\/code> and williamhill<\/code>. Dedupe on the price tuple before you count anything.<\/p>\n

Step 1: Read limits off the live feed<\/h2>\n

Auth is a query parameter, never a header. Pull the fixture, walk the nested payload, keep the limit alongside the price.<\/p>\n

import requests\n\nAPI_KEY = \"YOUR_API_KEY\"\nBASE_URL = \"https:\/\/api.oddspapi.io\/v4\"\nFIXTURE = \"id1300010963301639\"   # Marlins at Phillies\nMONEYLINE = \"131\"                # Winner (incl. extra innings)\n\n\ndef get_odds(fixture_id):\n    r = requests.get(f\"{BASE_URL}\/odds\",\n                     params={\"apiKey\": API_KEY, \"fixtureId\": fixture_id})\n    r.raise_for_status()\n    return r.json()\n\n\ndef read_prices(odds, market_id):\n    \"\"\"[{book, outcome, price, limit, ladder}] for one market.\"\"\"\n    rows = []\n    for slug, book in odds.get(\"bookmakerOdds\", {}).items():\n        market = book.get(\"markets\", {}).get(market_id)\n        if not market:\n            continue\n        for outcome_id, outcome in market[\"outcomes\"].items():\n            price = outcome[\"players\"].get(\"0\")\n            if not price or price.get(\"active\") is False:\n                continue\n            rows.append({\n                \"book\": slug,\n                \"outcome\": outcome_id,\n                \"price\": price[\"price\"],\n                \"limit\": price.get(\"limit\"),\n                \"ladder\": (price.get(\"exchangeMeta\") or {}).get(\"back\"),\n            })\n    return rows\n\n\nrows = read_prices(get_odds(FIXTURE), MONEYLINE)\nfor r in sorted(rows, key=lambda r: -(r[\"limit\"] or 0)):\n    if r[\"outcome\"] == \"131\":\n        print(f\"{r['book']:20} {r['price']:>7}  limit={r['limit']}\")\n<\/code><\/pre>\n
Two traps in those eight lines. Filter on active is False<\/code> rather than truthy active<\/code>, because the feed ships active: null<\/code> alongside perfectly good prices on pre-game fixtures. And treat both null<\/code> and {}<\/code> as “no exchange data”, because older payloads used the empty dict.<\/p>\n
Step 2: Pinnacle publishes a max win, not a max stake<\/h2>\n
Look at the two sides of the Marlins moneyline. Miami at 1.925 has a limit of $8,108. Philadelphia at 2.0 has a limit of $7,500. Same market, same fixture, different caps. Multiply each limit by the profit per unit and the reason appears:<\/p>\n
def max_win(price, limit):\n    return round(limit * (price - 1), 2)\n\nmax_win(1.925, 8108)   # 7499.90\nmax_win(2.00, 7500)    # 7500.00\nmax_win(1.465, 16129)  # 7500.00   run line, other side\nmax_win(1.529, 14177)  # 7499.63   alt handicap\nmax_win(1.18, 41666)   # 7499.88   deep favourite\n<\/code><\/pre>\n
Pinnacle is not capping your stake. It is capping its own loss. The rule that reproduces every limit on the fixture is:<\/p>\n
limit = max(base, base \/ (price - 1))\n<\/code><\/pre>\n
Where base<\/code> is a per-market figure the book sets by how much it trusts its own number. On a 1.18 favourite that formula hands you a $41,666 limit, because you would have to stake $41,666 to win the same $7,500 that a $7,500 stake wins at evens. I checked the rule against two more MLB fixtures on the same slate and it held on the moneyline, the run line and the total every time.<\/p>\n
Step 3: The limit tells you where the book is unsure<\/h2>\n
Run that base calculation across every Pinnacle market on one fixture and you get a confidence map, published by the book, for free:<\/p>\n
\n\n\n\n\n\n\n\n\n\n\n\n
Market<\/th>\nImplied base (max win)<\/th>\nLimit at evens<\/th>\n<\/tr>\n<\/thead>\n
Winner, full game<\/td>\n$7,500<\/td>\n$8,108<\/td>\n<\/tr>\n
Run line -1.5<\/td>\n$7,500<\/td>\n$16,129 on the favourite<\/td>\n<\/tr>\n
Total 8.5<\/td>\n$5,625<\/td>\n$5,625<\/td>\n<\/tr>\n
Handicap, first five innings<\/td>\n$3,750<\/td>\n$3,750<\/td>\n<\/tr>\n
Alternate handicap +3<\/td>\n$1,875<\/td>\n$1,875<\/td>\n<\/tr>\n
Over\/under, first inning<\/td>\n$750<\/td>\n$795<\/td>\n<\/tr>\n
Exact runs<\/td>\n$375<\/td>\n$375<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/figure>\n
The moneyline carries twenty-one times the size of the exact-runs market. Pinnacle has priced thousands of MLB moneylines and it knows where its number sits. It has priced far fewer exact-runs markets and it hedges by refusing size.<\/p>\n
Now hold that against where your model probably finds an edge. Nobody beats the Pinnacle moneyline by 3%. Plenty of people find soft numbers in first-inning totals and exact-runs derivatives, which is exactly where the book will take $375 and then move. Your edge and the available size are inversely correlated, and the limit<\/code> field prices that trade-off for you before you write a staking plan.<\/p>\n
Step 4: Exchange ladders, and what size means<\/h2>\n
Exchanges go further than a single cap. exchangeMeta<\/code> carries a list of price levels with the capital resting at each. Here is the Polymarket back ladder on Miami:<\/p>\n
\n\n\n\n\n\n\n\n
Level<\/th>\nPrice<\/th>\nsize<\/code><\/th>\nlimit<\/code><\/th>\ncents<\/code><\/th>\n<\/tr>\n<\/thead>\n
1<\/td>\n1.961<\/td>\n151,235.08<\/td>\n77,129.89<\/td>\n0.51<\/td>\n<\/tr>\n
2<\/td>\n1.923<\/td>\n70,385.38<\/td>\n36,600.40<\/td>\n0.52<\/td>\n<\/tr>\n
3<\/td>\n1.887<\/td>\n84,154.67<\/td>\n44,601.98<\/td>\n0.53<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/figure>\n
The two money columns mean different things and mixing them up will cost you. size<\/code> is the payout available at that level. limit<\/code> is the stake required to take all of it. They tie together through the native share price: 151,235.08 shares at 51 cents is $77,129.89 of stake. The relationship held on every level of both Polymarket and Kalshi that I checked.<\/p>\n
The outcome-level limit<\/code> field on an exchange is just the top level of that ladder. To fill more, you walk down and pay worse prices:<\/p>\n
def walk_ladder(levels, target_stake):\n    \"\"\"Fill target_stake down a back ladder. Returns (filled, avg_price).\"\"\"\n    filled, payout = 0.0, 0.0\n    for level in levels or []:\n        take = min(level[\"limit\"], target_stake - filled)\n        if take <= 0:\n            break\n        filled += take\n        payout += take * level[\"price\"]\n    if filled == 0:\n        return 0.0, None\n    return round(filled, 2), round(payout \/ filled, 4)\n<\/code><\/pre>\n
Three levels is what the feed carries, and on this fixture they added up to $158,332 of back capacity. Ask for $200,000 and you get $158,332 at a blended 1.9314. The rest does not exist until someone posts it.<\/p>\n
Parse this defensively. Kalshi and Polymarket both ship the back<\/code> and lay<\/code> lists shown above, but the shape varies across exchange slugs: Betfair uses availableToBack<\/code> and availableToLay<\/code>, some payloads carry a flat scalar, and inactive markets can return a list where you expected an object. Check the type before you iterate.<\/p>\n
Step 5: What size does to your edge<\/h2>\n
Say your model prices Miami at 1.90, so you make the true probability 52.6%. The best available price is 1.961 and you want to know what that is worth. Run the ladder walk at increasing sizes and compute EV on the blended fill rather than the headline number:<\/p>\n
\n\n\n\n\n\n\n\n\n\n
Target stake<\/th>\nFilled<\/th>\nBlended price<\/th>\nEV<\/th>\n<\/tr>\n<\/thead>\n
$25,000<\/td>\n$25,000<\/td>\n1.961<\/td>\n+3.21%<\/td>\n<\/tr>\n
$77,129<\/td>\n$77,129<\/td>\n1.961<\/td>\n+3.21%<\/td>\n<\/tr>\n
$100,000<\/td>\n$100,000<\/td>\n1.9523<\/td>\n+2.75%<\/td>\n<\/tr>\n
$150,000<\/td>\n$150,000<\/td>\n1.9338<\/td>\n+1.78%<\/td>\n<\/tr>\n
$200,000<\/td>\n$158,332<\/td>\n1.9314<\/td>\n+1.65%<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/figure>\n
Going from $25,000 to $150,000 costs you 45% of your edge, and you never got a worse price than the third level of one order book. Scale that thinking across a slate and you understand why professional operations obsess over distribution. The edge per dollar shrinks as the dollars grow, and the only fix is more venues.<\/p>\n
Step 6: Spread the stake across books<\/h2>\n
Which is what this does. Sort by price, take what each venue will give you, walk ladders where they exist, fall back to a conservative assumption where the book hides its limit:<\/p>\n
def allocate(rows, outcome_id, target_stake, fallback_limit=500):\n    \"\"\"Spread a target stake over the best-priced books that will take it.\"\"\"\n    book_rows = sorted([r for r in rows if r[\"outcome\"] == outcome_id],\n                       key=lambda r: -r[\"price\"])\n    plan, filled, payout = [], 0.0, 0.0\n    for r in book_rows:\n        if filled >= target_stake:\n            break\n        if r[\"ladder\"]:\n            take, price = walk_ladder(r[\"ladder\"], target_stake - filled)\n        else:\n            cap = r[\"limit\"] if r[\"limit\"] is not None else fallback_limit\n            take, price = min(cap, target_stake - filled), r[\"price\"]\n        if not take:\n            continue\n        plan.append((r[\"book\"], take, price))\n        filled += take\n        payout += take * price\n    return plan, round(filled, 2), round(payout \/ filled, 4) if filled else None\n<\/code><\/pre>\n
Set fallback_limit<\/code> from your own account history at each soft book. That is the one input the API cannot give you, and guessing high is how you end up with a plan that assumes $5,000 at BetMGM and gets $200.<\/p>\n
The allocator also doubles as a reality check on line shopping<\/a>. Best price across 350+ books is the right target when you are staking $200. At $50,000 the question changes to best blended<\/em> price, and the book with the third-best number and real depth beats the headline quote.<\/p>\n
Step 7: Limits ramp toward first pitch<\/h2>\n
Limits are not static, and the free \/historical-odds<\/code> endpoint records them. Pinnacle logged 43 moneyline snapshots on this fixture, and the limit quadrupled inside 21 hours:<\/p>\n
\n\n\n\n\n\n\n\n\n
Timestamp (UTC)<\/th>\nPrice<\/th>\nLimit<\/th>\nImplied max win<\/th>\n<\/tr>\n<\/thead>\n
27 Jul 21:30<\/td>\n1.943<\/td>\n$1,988<\/td>\n$1,875<\/td>\n<\/tr>\n
28 Jul 08:42<\/td>\n1.925<\/td>\n$2,027<\/td>\n$1,875<\/td>\n<\/tr>\n
28 Jul 15:08<\/td>\n1.925<\/td>\n$6,081<\/td>\n$5,625<\/td>\n<\/tr>\n
28 Jul 16:25<\/td>\n1.925<\/td>\n$8,108<\/td>\n$7,500<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/figure>\n
def limit_history(fixture_id, book, market_id, outcome_id):\n    r = requests.get(f\"{BASE_URL}\/historical-odds\",\n                     params={\"apiKey\": API_KEY, \"fixtureId\": fixture_id,\n                             \"bookmakers\": book})   # max 3 books per call\n    r.raise_for_status()\n    market = r.json()[\"bookmakers\"][book][\"markets\"][market_id]\n    snaps = market[\"outcomes\"][outcome_id][\"players\"][\"0\"]\n    return [(s[\"createdAt\"][:16], s[\"price\"], s.get(\"limit\")) for s in snaps]\n<\/code><\/pre>\n
The base moved in steps: $1,875 the night before, $5,625 by mid-afternoon, $7,500 an hour after that. Pinnacle raises its exposure as the market fills in and its number gets sharper. Polymarket did the same thing from the other direction, growing from $8 of top-of-book depth six days out to $77,000 on game day across 26,477 snapshots.<\/p>\n
The practical consequence: an edge you find at 9am may only be fillable at 5pm, by which time the price has usually moved against you. Log limits alongside prices in your own odds database<\/a> and you can measure that trade-off on your own markets instead of guessing at it.<\/p>\n
What this changes about your staking<\/h2>\n
Most staking tutorials, including our own Kelly guide<\/a>, compute a number and stop. Kelly on a $500,000 bank with a 3.2% edge will tell you to stake five figures without blinking. Whether that stake exists is a separate question with a separate data source, and now you have it.<\/p>\n
Three changes worth making today. Clip every Kelly output to the fillable size before you log it as a bet. Compute EV on the blended fill price rather than the top-of-book quote. And when you run a risk-of-ruin simulation<\/a>, feed it the sizes you can actually get on, because a strategy that needs $40,000 per bet in a market with $375 limits has a ruin probability you cannot compute from returns alone.<\/p>\n
None of this requires an enterprise contract. The limit<\/code> field, the full exchange ladders, and the historical snapshots that show limits moving are all on the free tier, alongside 350+ bookmakers and the sharps that actually publish their exposure. Ranogajec needed a network of accounts and people to answer the size question. You need one endpoint.<\/p>\n
Get your free API key<\/a> and find out what your edge is worth at scale.<\/p>\n
Frequently Asked Questions<\/h2>\n
Which bookmakers publish a betting limit in the OddsPapi API?<\/h3>\n
Pinnacle and the prediction-market exchanges populate the limit<\/code> field on every outcome. On our MLB test fixture, Pinnacle, Kalshi and Polymarket all carried a limit while the other ten books returned null<\/code>. US retail books such as DraftKings, FanDuel, BetMGM and Caesars leave it empty because their maximum bet is set per account rather than per market. Check for None<\/code> before doing arithmetic on it.<\/p>\n
What does the limit field actually mean?<\/h3>\n
On a sportsbook it is the maximum stake the book will accept on that outcome at that price. On an exchange it is the stake needed to consume the top level of the order book, with deeper levels listed separately in exchangeMeta<\/code>. Both are quoted in the account currency.<\/p>\n
Why is Pinnacle’s limit different on each side of the same market?<\/h3>\n
Pinnacle caps its own maximum loss rather than your stake. The limit on any outcome is max(base, base \/ (price - 1))<\/code>, where base<\/code> is a per-market figure. A $7,500 base gives an $8,108 limit at 1.925 and a $41,666 limit at 1.18, because both stakes win the book’s maximum of $7,500.<\/p>\n
How do I read size versus limit on an exchange ladder?<\/h3>\n
size<\/code> is the payout available at that level and limit<\/code> is the stake required to take it, linked by the native share price in cents<\/code>. On Polymarket, 151,235 shares at 0.51 works out to $77,130 of stake. Use limit<\/code> when you are walking a ladder to fill a target stake.<\/p>\n
Can I get limit history on the free tier?<\/h3>\n
Yes. Every snapshot from \/historical-odds<\/code> carries the limit that applied at that timestamp, so you can chart how a book scaled its exposure into kickoff. The endpoint accepts a maximum of three bookmakers per call, so loop and merge for wider coverage.<\/p>\n