{"id":2509,"date":"2026-03-17T10:00:00","date_gmt":"2026-03-17T10:00:00","guid":{"rendered":"https:\/\/oddspapi.io\/blog\/?p=2509"},"modified":"2026-03-13T13:27:54","modified_gmt":"2026-03-13T13:27:54","slug":"arbitrage-betting-bot-python","status":"publish","type":"post","link":"https:\/\/oddspapi.io\/blog\/arbitrage-betting-bot-python\/","title":{"rendered":"How to Build an Arbitrage Betting Bot with Python (Free API)"},"content":{"rendered":"

What Is Arbitrage Betting?<\/h2>\n

Arbitrage betting (“arbing”) is the practice of betting on every possible outcome<\/strong> of an event across different bookmakers, where the combined implied probability is less than 100%. The result: guaranteed profit regardless of who wins.<\/p>\n

Here is a quick example. A soccer match has three outcomes (Home, Draw, Away):<\/p>\n

\n\n\n\n\n\n\n\n
Outcome<\/th>\nBookmaker<\/th>\nOdds<\/th>\nImplied Prob<\/th>\n<\/tr>\n<\/thead>\n
Home Win<\/td>\nPinnacle<\/td>\n2.55<\/td>\n39.2%<\/td>\n<\/tr>\n
Draw<\/td>\nBet365<\/td>\n3.80<\/td>\n26.3%<\/td>\n<\/tr>\n
Away Win<\/td>\n1xBet<\/td>\n3.20<\/td>\n31.3%<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/figure>\n

Total implied probability: 96.8%<\/strong>. That is under 100%, which means you can stake proportionally on all three outcomes and lock in a 3.2% profit no matter what happens.<\/p>\n

The catch? To find arbs, you need odds from as many bookmakers as possible<\/strong>. The more books you cover, the more arbs you find. That is why most arb scanners fail — they only check 20–40 soft bookmakers.<\/p>\n

Why Most Arbitrage Bots Fail<\/h2>\n

Before we build anything, let us talk about why most DIY arb bots produce zero results.<\/p>\n

1. Not Enough Bookmakers<\/h3>\n

The Odds API covers roughly 40 soft bookmakers. Arbs between soft books are razor-thin and vanish in seconds. Real, actionable arbs live in the spread between sharp bookmakers<\/strong> (Pinnacle, Singbet, SBOBet) and softs (Bet365, DraftKings, FanDuel). If your API does not carry sharps, you are scanning a puddle instead of an ocean.<\/p>\n

2. No Sharp Bookmakers<\/h3>\n

Pinnacle, Singbet, and SBOBet set the “true line.” When a soft bookmaker is slow to adjust, the gap between their price and the sharp line creates an arb. Most odds APIs do not carry these books at all. OddsPapi carries all three, plus 350+ total bookmakers including crypto and niche books like 1xBet and GG.BET.<\/p>\n

3. Polling Latency<\/h3>\n

If you poll every 30 seconds, the arb is gone before your code even prints it. The best arbs last seconds, not minutes. This is where WebSocket streaming<\/a> changes the game — OddsPapi pushes odds changes to you in real-time instead of waiting for you to ask.<\/p>\n

Building an Arb Bot: The Odds API vs OddsPapi<\/h2>\n
\n\n\n\n\n\n\n\n\n\n\n\n
Feature<\/th>\nThe Odds API<\/th>\nOddsPapi<\/th>\n<\/tr>\n<\/thead>\n
Bookmakers<\/td>\n~40 (soft only)<\/td>\n350+ (sharps + softs)<\/td>\n<\/tr>\n
Sharp Books (Pinnacle, Singbet)<\/td>\nNo<\/td>\nYes<\/td>\n<\/tr>\n
Crypto\/Niche Books<\/td>\nNo<\/td>\nYes (1xBet, GG.BET)<\/td>\n<\/tr>\n
Real-Time WebSocket<\/td>\nNo<\/td>\nYes<\/td>\n<\/tr>\n
Free Historical Data<\/td>\nNo<\/td>\nYes<\/td>\n<\/tr>\n
Free Tier<\/td>\n500 req\/month<\/td>\n250 req\/month<\/td>\n<\/tr>\n
Arb Detection Potential<\/td>\nLow (limited coverage)<\/td>\nHigh (sharp + soft spread)<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/figure>\n

The math is simple: more bookmakers = more price discrepancies = more arbs. With 350+ books including sharps, OddsPapi gives your scanner the coverage it needs to actually find opportunities.<\/p>\n

Build an Arbitrage Scanner in Python<\/h2>\n

Let us build a working arb scanner from scratch. This code is tested against the live OddsPapi API and ready to run.<\/p>\n

Step 1: Install Dependencies & Set Up<\/h3>\n
import requests\nfrom datetime import datetime, timedelta\n\nAPI_KEY = \"YOUR_API_KEY\"  # Get free at oddspapi.io\nBASE_URL = \"https:\/\/api.oddspapi.io\/v4\"<\/code><\/pre>\n
No extra libraries needed. Just requests<\/code> and the standard library. Grab your free API key<\/a> and drop it in.<\/p>\n
Step 2: Get Today’s Fixtures<\/h3>\n
def get_fixtures(sport_id=10):\n    \"\"\"Fetch today's fixtures. Sport 10 = Soccer.\"\"\"\n    today = datetime.now().strftime(\"%Y-%m-%d\")\n    tomorrow = (datetime.now() + timedelta(days=1)).strftime(\"%Y-%m-%d\")\n\n    response = requests.get(f\"{BASE_URL}\/fixtures\", params={\n        \"apiKey\": API_KEY,\n        \"sportId\": sport_id,\n        \"from\": today,\n        \"to\": tomorrow\n    })\n\n    fixtures = response.json()\n    # Filter to fixtures with odds available\n    return [f for f in fixtures if f.get(\"hasOdds\")]\n\n\nfixtures = get_fixtures()\nprint(f\"Found {len(fixtures)} fixtures with odds\")\nfor f in fixtures[:5]:\n    print(f\"  {f['participant1Name']} vs {f['participant2Name']} ({f['tournamentName']})\")<\/code><\/pre>\n
The \/fixtures<\/code> endpoint returns a flat list of fixtures. We filter on hasOdds<\/code> so we only scan matches that actually have pricing data from bookmakers.<\/p>\n
Step 3: Fetch Odds from All Bookmakers<\/h3>\n
def get_odds(fixture_id):\n    \"\"\"Get odds from all bookmakers for a fixture.\"\"\"\n    response = requests.get(f\"{BASE_URL}\/odds\", params={\n        \"apiKey\": API_KEY,\n        \"fixtureId\": fixture_id\n    })\n    return response.json()<\/code><\/pre>\n
One call, every bookmaker. The response contains a bookmakerOdds<\/code> dictionary keyed by bookmaker slug (e.g., pinnacle<\/code>, bet365<\/code>, singbet<\/code>). No pagination, no extra calls.<\/p>\n
Step 4: Find the Best Price for Each Outcome<\/h3>\n
def find_best_prices(odds_data, market_id=\"101\"):\n    \"\"\"Find the best price for each outcome across all bookmakers.\n\n    Market 101 = Full Time Result (1X2)\n    Outcomes: 101=Home, 102=Draw, 103=Away\n    \"\"\"\n    best = {}  # {outcome_id: {\"price\": float, \"bookmaker\": str}}\n\n    for slug, bookie in odds_data.get(\"bookmakerOdds\", {}).items():\n        market = bookie.get(\"markets\", {}).get(market_id)\n        if not market:\n            continue\n\n        for outcome_id, outcome in market.get(\"outcomes\", {}).items():\n            for player_id, player in outcome.get(\"players\", {}).items():\n                price = player.get(\"price\")\n                if price and (outcome_id not in best or price > best[outcome_id][\"price\"]):\n                    best[outcome_id] = {\n                        \"price\": price,\n                        \"bookmaker\": slug,\n                        \"outcome_id\": outcome_id\n                    }\n\n    return best<\/code><\/pre>\n
This is the core of the scanner. For each outcome in a market, we loop through every bookmaker and keep track of whoever is offering the highest price. The OddsPapi odds structure is nested: bookmakerOdds → slug → markets → marketId → outcomes → outcomeId → players → 0 → price<\/code>.<\/p>\n
Step 5: Calculate the Arbitrage Percentage<\/h3>\n
def check_arb(best_prices):\n    \"\"\"Check if an arbitrage opportunity exists.\n\n    If the sum of implied probabilities < 1.0, it's an arb.\n    Profit margin = (1 - sum) * 100\n    \"\"\"\n    if not best_prices:\n        return None\n\n    total_implied = sum(1 \/ bp[\"price\"] for bp in best_prices.values())\n    margin = (1 - total_implied) * 100\n\n    return {\n        \"is_arb\": total_implied < 1.0,\n        \"margin\": margin,\n        \"total_implied\": total_implied,\n        \"prices\": best_prices\n    }<\/code><\/pre>\n
The formula is straightforward. Convert each best price to its implied probability (1 \/ odds<\/code>), sum them up. If the total is under 1.0 (100%), you have an arb. The margin tells you how much guaranteed profit you can extract.<\/p>\n
Step 6: Scan All Fixtures<\/h3>\n
def scan_for_arbs(sport_id=10, market_id=\"101\"):\n    \"\"\"Scan all fixtures for arbitrage opportunities.\"\"\"\n    fixtures = get_fixtures(sport_id)\n    print(f\"Scanning {len(fixtures)} fixtures for arbs...\\n\")\n\n    arbs_found = []\n\n    for fixture in fixtures:\n        fid = fixture[\"fixtureId\"]\n        name = f\"{fixture['participant1Name']} vs {fixture['participant2Name']}\"\n\n        odds_data = get_odds(fid)\n        best_prices = find_best_prices(odds_data, market_id)\n        result = check_arb(best_prices)\n\n        if result and result[\"is_arb\"]:\n            arbs_found.append({\"fixture\": name, **result})\n            print(f\"ARB FOUND: {name}\")\n            print(f\"   Margin: {result['margin']:.2f}%\")\n            for oid, bp in result[\"prices\"].items():\n                print(f\"   Outcome {oid}: {bp['price']} @ {bp['bookmaker']}\")\n            print()\n        else:\n            overround = -result[\"margin\"] if result else 0\n            bookmakers = len(odds_data.get(\"bookmakerOdds\", {}))\n            print(f\"  {name}: {bookmakers} books, {overround:.1f}% overround\")\n\n    print(f\"\\n{'='*50}\")\n    print(f\"Scanned {len(fixtures)} fixtures\")\n    print(f\"Arbs found: {len(arbs_found)}\")\n\n    return arbs_found\n\n\n# Run the scanner\narbs = scan_for_arbs()<\/code><\/pre>\n
Run this and watch it scan every fixture. With 350+ bookmakers feeding prices, you will see arbs that scanners limited to 40 soft books will never detect.<\/p>\n
Taking It Further: Multi-Market & Real-Time Scanning<\/h2>\n
The scanner above covers the 1X2 (Full Time Result) market. But arbs hide in other markets too. Here is how to expand it.<\/p>\n
Scan Multiple Markets<\/h3>\n
Loop through several markets to multiply your opportunities. Each market has its own set of outcomes and its own set of bookmaker pricing inefficiencies.<\/p>\n
MARKETS = {\n    \"101\": \"Full Time Result (1X2)\",\n    \"1010\": \"Over\/Under 2.5 Goals\",\n    \"104\": \"Both Teams to Score\"\n}\n\nfor market_id, market_name in MARKETS.items():\n    print(f\"\\n--- {market_name} ---\")\n    arbs = scan_for_arbs(market_id=market_id)<\/code><\/pre>\n
Over\/Under and BTTS markets often have more arbs than 1X2 because they are two-outcome markets — fewer outcomes means the margin between bookmakers needs to be smaller to create an arb, and it happens more often.<\/p>\n
Calculate Optimal Stakes<\/h3>\n
Once you find an arb, you need to know exactly how much to bet on each outcome to guarantee profit.<\/p>\n
def calculate_stakes(best_prices, total_stake=100):\n    \"\"\"Calculate how much to bet on each outcome for guaranteed profit.\"\"\"\n    total_implied = sum(1 \/ bp[\"price\"] for bp in best_prices.values())\n\n    stakes = {}\n    for outcome_id, bp in best_prices.items():\n        implied = 1 \/ bp[\"price\"]\n        stake = (implied \/ total_implied) * total_stake\n        payout = stake * bp[\"price\"]\n        stakes[outcome_id] = {\n            \"bookmaker\": bp[\"bookmaker\"],\n            \"price\": bp[\"price\"],\n            \"stake\": round(stake, 2),\n            \"payout\": round(payout, 2)\n        }\n\n    profit = (1 \/ total_implied - 1) * total_stake\n\n    return {\"stakes\": stakes, \"profit\": round(profit, 2), \"roi\": round((1\/total_implied - 1) * 100, 2)}<\/code><\/pre>\n
The function distributes your total stake proportionally across outcomes so that every outcome pays out the same amount. The difference between total payout and total stake is your guaranteed profit.<\/p>\n
Upgrade to WebSocket for Real-Time Detection<\/h3>\n
Polling the REST API every 30 seconds works for finding arbs, but most of them will have closed by the time you place your bets. The real edge comes from real-time WebSocket streaming<\/strong>. OddsPapi pushes odds changes to your bot the instant they happen, cutting your detection latency from 30 seconds to milliseconds.<\/p>\n
WebSocket access requires a Pro tier plan. For the full setup guide, check out our WebSocket Odds API tutorial<\/a>.<\/p>\n
FAQ: Arbitrage Betting Bots<\/h2>\n
Is arbitrage betting legal?<\/h3>\n
Yes, arbitrage betting is legal in most jurisdictions. You are simply placing bets at different bookmakers. However, bookmakers do not like arbers and may limit or close your accounts if they detect consistent arb activity. Using multiple accounts and varying your bet sizes can help extend account longevity.<\/p>\n
How many bookmakers do I need for arbs?<\/h3>\n
The more bookmakers your scanner covers, the more arbs you will find. With 40 soft-only books (like The Odds API provides), you will find close to zero actionable arbs. With 350+ books including sharps like Pinnacle and Singbet, you will find several opportunities daily. The sharp-to-soft spread is where the real arbs live.<\/p>\n
What sports have the most arbitrage opportunities?<\/h3>\n
Soccer has the most arbs because it has the widest bookmaker coverage globally. Tennis is also strong because it is a two-outcome market (no draw), which makes arbs more common. Niche markets like esports and regional leagues also produce arbs because fewer bookmakers price them efficiently.<\/p>\n
Do I need a paid API plan?<\/h3>\n
The free tier (250 requests\/month) is enough to build and test your scanner. For production scanning across multiple sports and markets, you will want a paid plan for higher rate limits. For real-time WebSocket alerts, you need the Pro tier.<\/p>\n
How long do arbitrage opportunities last?<\/h3>\n
Most arbs last seconds to a few minutes. Sharp bookmakers like Pinnacle move fast, and soft books adjust their lines accordingly. This is why polling-based scanners miss most arbs. Real-time WebSocket detection gives you the speed advantage you need.<\/p>\n
Can I use this with Pinnacle?<\/h3>\n
Yes. OddsPapi aggregates odds from Pinnacle, Singbet, SBOBet, and other sharp bookmakers that most APIs do not carry. You do not need a Pinnacle commercial account or API key — OddsPapi handles the data aggregation for you.<\/p>\n