{"id":3114,"date":"2026-07-16T10:00:00","date_gmt":"2026-07-16T10:00:00","guid":{"rendered":"https:\/\/oddspapi.io\/blog\/?p=3114"},"modified":"2026-06-21T19:11:47","modified_gmt":"2026-06-21T19:11:47","slug":"risk-of-ruin-bankroll-simulator-python","status":"publish","type":"post","link":"https:\/\/oddspapi.io\/blog\/risk-of-ruin-bankroll-simulator-python\/","title":{"rendered":"Risk of Ruin: Simulate Your Betting Bankroll in Python (Free Odds API)"},"content":{"rendered":"

You Found a +EV Bet. Will It Grow Your Bankroll, or Bust You?<\/h2>\n

Every value-betting tutorial ends the moment you find an edge. You de-vig a sharp line, spot a price that beats fair value, and the post congratulates you. Nobody tells you the part that actually decides whether you make money: how much to stake, and what the next 500 bets will do to your bankroll along the way.<\/p>\n

Here is the uncomfortable truth. A real, positive-expectation edge can still wipe you out if you bet too big, and it can crawl sideways for a whole season even when the math says you are winning. The only way to see that before it happens to your money is to simulate it. This post builds a Monte Carlo bankroll simulator in Python, seeded with a real edge pulled live from the OddsPapi feed, and shows you the risk of ruin and drawdown for four different staking plans.<\/p>\n

If you have not yet found an edge to simulate, start with the expected value betting guide<\/a> and the Kelly staking calculator<\/a>. This post picks up where those leave off: you have an edge, now will you survive it?<\/p>\n

An Edge Is Necessary. It Is Not Sufficient.<\/h2>\n

The Kelly criterion gives you a single number: the stake fraction that maximizes long-run growth. What it does not show you is the ride. Two bettors with the identical +1.5% edge can end a season one up 80% and the other down to scraps, purely from staking and variance. A point estimate hides the distribution, and the distribution is where ruin lives.<\/p>\n

A Monte Carlo simulation runs your exact edge through thousands of simulated seasons and shows you the whole spread: the median outcome, the unlucky 5th percentile, how often you would have gone broke, and how deep your worst drawdown got. That is the difference between “the formula says bet 1.3%” and “if I bet 3% I have a 2.7% chance of busting and will routinely sit through 56% drawdowns.”<\/p>\n

\n\n\n\n\n\n\n\n\n
Single-bet calculator<\/th>\nMonte Carlo simulator<\/th>\n<\/tr>\n<\/thead>\n
One stake number, no context<\/td>\nFull distribution of 20,000 simulated seasons<\/td>\n<\/tr>\n
Silent on variance<\/td>\n5th\/95th percentile bankroll, max drawdown<\/td>\n<\/tr>\n
Assumes you survive to the long run<\/td>\nComputes the probability you do not (risk of ruin)<\/td>\n<\/tr>\n
Ignores overbetting risk<\/td>\nShows exactly where overbetting tips into ruin<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/figure>\n

Step 1: Get a Real Edge to Simulate<\/h2>\n

Garbage in, garbage out. Do not simulate a made-up 10% edge that no sharp market would ever leave on the table. Pull a real one. The cleanest source is a tight sharp line de-vigged into a fair probability, then compared against the best available price across the book. Here is the live pull on a real MLB fixture, Seattle Mariners vs Boston Red Sox, captured June 21 with 16 books on the moneyline (market id 131<\/code>):<\/p>\n

import requests\n\nAPI_KEY = \"YOUR_API_KEY\"\nBASE = \"https:\/\/api.oddspapi.io\/v4\"\n\ndef get_odds(fixture_id):\n    r = requests.get(f\"{BASE}\/odds\",\n                     params={\"apiKey\": API_KEY, \"fixtureId\": fixture_id})\n    return r.json()[\"bookmakerOdds\"]\n\ndef price(bo, slug, market=\"131\", outcome=\"131\"):\n    try:\n        node = bo[slug][\"markets\"][market][\"outcomes\"][outcome][\"players\"][\"0\"]\n        return node[\"price\"] if node.get(\"active\") and node[\"price\"] > 0 else None\n    except (KeyError, TypeError):\n        return None\n\nbo = get_odds(\"id1300010963303711\")  # Mariners v Red Sox\n\n# Pinnacle is the sharp anchor. De-vig the two-way market.\npin_home, pin_away = price(bo, \"pinnacle\", \"131\", \"131\"), price(bo, \"pinnacle\", \"131\", \"132\")\ninv_h, inv_a = 1 \/ pin_home, 1 \/ pin_away\noverround = inv_h + inv_a\nfair_away = inv_a \/ overround          # de-vigged true probability\n\n# Best price available on the away side, across all 16 books.\nbest = max((price(bo, s, \"131\", \"132\"), s) for s in bo if price(bo, s, \"131\", \"132\"))\nbest_price, best_book = best\nedge = fair_away * best_price - 1\n\nprint(f\"Pinnacle vig: {(overround - 1) * 100:.2f}%\")\nprint(f\"Fair away prob: {fair_away * 100:.1f}%  (fair odds {1\/fair_away:.3f})\")\nprint(f\"Best away price: {best_price} @ {best_book}  ->  edge {edge * 100:+.2f}%\")<\/code><\/pre>\n
Real output: Pinnacle’s vig was a razor-thin 1.97%<\/strong>, the de-vigged fair probability on the Red Sox was 46.7%<\/strong> (fair odds 2.141), and the best available price was 2.174 at Kalshi<\/strong>, which is a genuine +1.53% edge<\/strong>. That is what a real edge looks like: small, sharp-anchored, and nothing like the fantasy numbers in most tutorials. (Ignore the 37% “edge” you will occasionally see from a stale or boosted soft-book price; those are data artifacts, not money, as covered in line shopping<\/a>.) This is the input we feed the simulator: win probability 0.467, decimal odds 2.174.<\/p>\n
Step 2: Build the Monte Carlo Simulator<\/h2>\n
The simulator is dependency-free, just Python’s random<\/code>. Each simulated season is a loop of bets; each bet wins with our true probability and pays the decimal odds, or loses the stake. We run twenty thousand seasons and record where each one lands, whether it ever dipped below a “give up” ruin threshold, and its worst peak-to-trough drawdown.<\/p>\n
import random\n\nP_WIN = 0.467     # de-vigged true probability (from Step 1)\nODDS  = 2.174     # decimal odds we are getting\nb = ODDS - 1\nkelly_full = (b * P_WIN - (1 - P_WIN)) \/ b   # full-Kelly fraction\n\ndef simulate(stake_fn, n_bets=500, n_sims=20000,\n             start=100.0, ruin_at=20.0, seed=42):\n    random.seed(seed)\n    finals, max_dd, ruined = [], [], 0\n    for _ in range(n_sims):\n        bank = peak = start\n        worst_dd = 0.0\n        is_ruined = False\n        for _ in range(n_bets):\n            stake = min(stake_fn(bank), bank)\n            if random.random() < P_WIN:\n                bank += stake * (ODDS - 1)\n            else:\n                bank -= stake\n            peak = max(peak, bank)\n            worst_dd = max(worst_dd, (peak - bank) \/ peak)\n            if bank <= ruin_at:\n                is_ruined = True\n        finals.append(bank)\n        max_dd.append(worst_dd)\n        ruined += is_ruined\n    finals.sort()\n    return {\n        \"median\": finals[len(finals) \/\/ 2],\n        \"p5\":  finals[int(len(finals) * 0.05)],\n        \"p95\": finals[int(len(finals) * 0.95)],\n        \"ruin_pct\": ruined \/ n_sims * 100,\n        \"avg_max_dd\": sum(max_dd) \/ len(max_dd) * 100,\n    }\n\nprint(f\"edge {(P_WIN*ODDS-1)*100:.2f}%   full-Kelly {kelly_full*100:.2f}%\")<\/code><\/pre>\n
That prints edge 1.53%   full-Kelly 1.30%<\/code>. So the math says a +1.53% edge justifies staking just 1.30% of your bankroll per bet. Hold that number; the next step shows what happens when you respect it and when you do not.<\/p>\n
Step 3: Run It Across Four Staking Plans<\/h2>\n
We test four ways to size the same bet on the same edge over a 500-bet season, starting from a 100-unit bankroll:<\/p>\n
plans = {\n    \"Flat 1 unit (fixed)\":   lambda bank: 1.0,\n    \"Flat 3% of bankroll\":   lambda bank: 0.03 * bank,\n    \"Full Kelly (1.30%)\":    lambda bank: kelly_full * bank,\n    \"Quarter Kelly (0.33%)\": lambda bank: 0.25 * kelly_full * bank,\n}\nfor name, fn in plans.items():\n    r = simulate(fn)\n    print(f\"{name:24} median {r['median']:6.1f}  \"\n          f\"5th {r['p5']:5.1f}  95th {r['p95']:6.1f}  \"\n          f\"ruin {r['ruin_pct']:.2f}%  avg maxDD {r['avg_max_dd']:.0f}%\")<\/code><\/pre>\n
Real output (reproducible with seed=42<\/code>):<\/p>\n
\n\n\n\n\n\n\n\n\n
Staking plan<\/th>\nMedian end<\/th>\n5th pct<\/th>\n95th pct<\/th>\nRisk of ruin<\/th>\nAvg max drawdown<\/th>\n<\/tr>\n<\/thead>\n
Flat 1 unit (fixed)<\/td>\n108.7<\/td>\n67.4<\/td>\n147.8<\/td>\n0.06%<\/td>\n23.1%<\/td>\n<\/tr>\n
Flat 3% of bankroll<\/td>\n99.8<\/td>\n29.0<\/td>\n321.8<\/td>\n2.66%<\/td>\n56.4%<\/td>\n<\/tr>\n
Full Kelly (1.30%)<\/td>\n106.6<\/td>\n62.3<\/td>\n177.1<\/td>\n0.00%<\/td>\n29.5%<\/td>\n<\/tr>\n
Quarter Kelly (0.33%)<\/td>\n102.6<\/td>\n89.7<\/td>\n116.5<\/td>\n0.00%<\/td>\n8.2%<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/figure>\n
Step 4: Read the Results Like a Risk Manager<\/h2>\n
Four lessons fall straight out of that table, and none of them are visible from a single-bet calculator.<\/p>\n
Overbetting a real edge can still leave you flat<\/h3>\n
Flat 3% is more than double the Kelly-optimal 1.30%. Despite betting a genuinely +EV edge 500 times, its median season ends at 99.8<\/strong>, essentially break-even, with a brutal 56% average drawdown and a 2.66% chance of effective ruin. This is volatility drag: when you overbet, the geometric growth rate goes negative even though each individual bet has positive expectation. The typical outcome is flat-to-down while a few lucky seasons (the 321.8 at the 95th percentile) drag the average up. You do not get the average; you get the median.<\/p>\n
Risk of ruin is a staking problem, not an edge problem<\/h3>\n
Same edge, same bets, four different ruin probabilities: 0.06%, 2.66%, 0.00%, 0.00%. The edge never changed. What changed was how much you risked per bet. Ruin is something you choose through your stake size, not something the market does to you.<\/p>\n
Full Kelly is correct and still uncomfortable<\/h3>\n
Full Kelly posts the best median growth of the proportional plans (106.6) with zero ruin, but it routinely sits through 29.5% drawdowns. That is mathematically optimal and emotionally very hard. Most disciplined bettors cannot stomach it, which is exactly why fractional Kelly exists.<\/p>\n
Quarter Kelly buys a smooth ride cheaply<\/h3>\n
Dropping to quarter Kelly cuts the average max drawdown from 29.5% to 8.2%<\/strong> and tightens the whole distribution (89.7 to 116.5) while giving up only a little median growth (102.6 vs 106.6). For a thin real-world edge with imperfect probability estimates, that trade is almost always worth it. When your \"true\" probability is itself uncertain, betting smaller protects you from the times you were wrong about the edge.<\/p>\n
Make It Yours: Backtest on Free Historical Data<\/h2>\n
The simulation above assumes one fixed edge. Real bettors face a stream of different edges and odds. The honest next step is to replace the single P_WIN<\/code>\/ODDS<\/code> pair with a list of real historical bets and their de-vigged fair probabilities, then run the same bankroll loop over that sequence. OddsPapi's \/historical-odds<\/code> endpoint gives you the full opening-to-closing price timeline for free, so you can reconstruct what a staking plan would have done across an actual season. The mechanics of pulling and flattening those timelines are in the backtesting guide<\/a> and the historical odds to CSV<\/a> post. Seed the model with real edges from across 350+ bookmakers, including sharps and exchanges, and the simulator stops being a toy and starts being a risk model.<\/p>\n
Stop Guessing Your Stake. Get the Data.<\/h2>\n
A sharp-anchored edge and a free historical feed are all you need to simulate your real risk of ruin before it costs you. Get your free OddsPapi API key<\/a> and run your own bankroll through 20,000 seasons today.<\/p>\n
Frequently Asked Questions<\/h2>\n
What is risk of ruin in sports betting?<\/h3>\n
Risk of ruin is the probability that a staking plan drops your bankroll below a level you cannot recover from, even when your bets are positive expected value. It is driven almost entirely by how large you stake relative to your edge, not by the edge itself. Overbetting a real edge can still produce a meaningful chance of going broke.<\/p>\n
How do I calculate risk of ruin with Python?<\/h3>\n
Run a Monte Carlo simulation: loop thousands of simulated seasons where each bet wins with your true (de-vigged) probability and pays the decimal odds, track the bankroll, and count how often it falls below your ruin threshold. The dependency-free simulator in this post does exactly that, seeded with a real edge from the OddsPapi feed.<\/p>\n
Why does my +EV bet lose money in the simulation?<\/h3>\n
Volatility drag. When you stake more than the Kelly-optimal fraction, the geometric growth rate of your bankroll can turn negative even though each bet has positive expectation. The median (typical) outcome ends flat or down while a few lucky runs inflate the mean. In our example, flat 3% staking on a +1.53% edge had a median season of essentially break-even.<\/p>\n
Should I use full Kelly or fractional Kelly?<\/h3>\n
Full Kelly maximizes long-run growth but produces deep drawdowns (around 29% in our simulation) and assumes your probability estimate is exactly right. Because real edges are estimated with error, most disciplined bettors use a fraction such as quarter Kelly, which cut the average max drawdown to 8% in our run while sacrificing only a little growth.<\/p>\n
Where do I get a realistic edge to simulate?<\/h3>\n
De-vig a sharp bookmaker line (Pinnacle is the standard anchor) into a fair probability, then compare it to the best available price across the market. OddsPapi returns Pinnacle alongside 350+ other books in one call, so you can compute a real, current edge rather than guessing. In this post the live edge was +1.53% on the Red Sox at Kalshi versus Pinnacle's fair line.<\/p>\n