Category: Sports Betting & Odds

How to Scrape Betting Odds from Multiple Bookmakers

Scraping betting odds from bookmakers is one of the most technically demanding forms of web scraping. Bookmakers use cutting-edge anti-bot technology, serve odds through complex JavaScript frameworks, update prices every few seconds, and actively detect and block automated access. Yet the data is enormously valuable for odds comparison, market analysis, trading models, and research.

This guide provides a detailed, technical walkthrough for scraping odds from major bookmakers, with specific strategies for each platform and practical proxy configurations.

Bookmaker Landscape: Know Your Targets

Major International Bookmakers

Bookmaker	Base	Primary Tech Stack	Scraping Difficulty	Best Proxy Type
Bet365	UK	React, WebSocket	10/10	Mobile (UK)
Pinnacle	Curacao	React, REST API	5/10	Mobile (any)
Betfair Exchange	UK	Angular, REST API	6/10	Mobile (UK/IE)
William Hill	UK	React, WebSocket	8/10	Mobile (UK)
1xBet	Curacao	Custom framework	6/10	Mobile (varies)
Betway	Malta	React	7/10	Mobile (EU)

Asian Bookmakers

Bookmaker	Base	Primary Tech Stack	Scraping Difficulty	Best Proxy Type
Sbobet	Philippines	Custom, AJAX	7/10	Mobile (SEA)
Maxbet/IBCBet	Philippines	Custom	6/10	Mobile (SEA)
M88	Philippines	HTML + AJAX	5/10	Mobile (SEA)
W88	Philippines	HTML + JS	5/10	Mobile (SEA)
188bet	Isle of Man	React	6/10	Mobile (SEA/UK)
12BET	Philippines	HTML	4/10	Mobile (SEA)
Fun88	Philippines	Custom	5/10	Mobile (SEA)

Asian bookmakers are particularly important because they often set the market for football (soccer) odds. Sharp bettors and trading firms watch Asian lines closely because they tend to move first.

DataResearchTools mobile proxies cover all major Southeast Asian markets, making them ideal for scraping Asian bookmakers that require regional IP addresses.

Technical Approaches by Bookmaker

Bet365: The Hardest Target

Bet365 is widely considered the most difficult bookmaker to scrape. Their anti-bot measures include:

Custom JavaScript obfuscation that changes frequently
WebSocket-based odds delivery
Advanced browser fingerprinting
Geographic IP verification
Behavioral analysis (mouse movements, scroll patterns)
Device attestation

Approach: Full Browser Automation

from playwright.async_api import async_playwright
import asyncio
import json

class Bet365Scraper:
    def __init__(self, proxy_config):
        self.proxy = {
            "server": f"http://{proxy_config['host']}:{proxy_config['port']}",
            "username": proxy_config["user"],
            "password": proxy_config["pass"]
        }

    async def scrape(self, sport="soccer"):
        async with async_playwright() as p:
            browser = await p.chromium.launch(
                proxy=self.proxy,
                headless=False  # Bet365 detects headless browsers
            )

            context = await browser.new_context(
                viewport={"width": 412, "height": 915},
                user_agent=(
                    "Mozilla/5.0 (Linux; Android 14; SM-S918B) "
                    "AppleWebKit/537.36 (KHTML, like Gecko) "
                    "Chrome/121.0.0.0 Mobile Safari/537.36"
                ),
                locale="en-GB",
                timezone_id="Europe/London",
                geolocation={"latitude": 51.5074, "longitude": -0.1278},
                permissions=["geolocation"]
            )

            page = await context.new_page()

            # Intercept WebSocket messages for odds data
            ws_messages = []

            page.on("websocket", lambda ws: self.handle_websocket(ws, ws_messages))

            await page.goto("https://www.bet365.com", wait_until="networkidle")

            # Navigate to sport section
            await page.wait_for_timeout(3000)

            # Human-like interaction
            await self.simulate_human_behavior(page)

            # Navigate to target sport
            sport_link = await page.query_selector(f'text="{sport.title()}"')
            if sport_link:
                await sport_link.click()
                await page.wait_for_timeout(2000)

            # Collect odds from the page
            odds_data = await self.extract_odds(page)

            await browser.close()
            return odds_data

    async def simulate_human_behavior(self, page):
        """Simulate realistic human browsing"""
        import random

        # Random mouse movements
        for _ in range(random.randint(3, 7)):
            x = random.randint(50, 350)
            y = random.randint(100, 800)
            await page.mouse.move(x, y)
            await page.wait_for_timeout(random.randint(200, 800))

        # Random scroll
        await page.mouse.wheel(0, random.randint(100, 500))
        await page.wait_for_timeout(random.randint(500, 1500))

    def handle_websocket(self, ws, messages):
        """Capture WebSocket messages containing odds"""
        ws.on("framereceived", lambda data: messages.append(data))

    async def extract_odds(self, page):
        """Extract odds from the rendered page"""
        # Bet365 uses dynamic class names, so use structural selectors
        events = await page.query_selector_all("[class*='event']")

        results = []
        for event in events:
            try:
                teams = await event.query_selector_all("[class*='participant']")
                odds_cells = await event.query_selector_all("[class*='odds']")

                if teams and odds_cells:
                    result = {
                        "home": await teams[0].inner_text() if len(teams) > 0 else None,
                        "away": await teams[1].inner_text() if len(teams) > 1 else None,
                        "odds": [await cell.inner_text() for cell in odds_cells]
                    }
                    results.append(result)
            except Exception:
                continue

        return results

Critical notes for Bet365:

Use non-headless browsers (or undetectable headless setups)
Mobile proxies from the UK are essential since Bet365 verifies geographic location
Rotate browser profiles, not just IPs
Limit sessions to 15-20 minutes before creating a new one
DataResearchTools mobile proxies with UK endpoints provide the geographic authenticity Bet365 requires

Pinnacle: The Accessible Sharp Book

Pinnacle is the most scraper-friendly major bookmaker, partly because they welcome sharp bettors and do not limit winning accounts. Their odds serve as the market benchmark.

Approach: API-Style Scraping

import requests
from bs4 import BeautifulSoup

class PinnacleScraper:
    def __init__(self, proxy_config):
        self.proxy = {
            "http": f"http://{proxy_config['user']}:{proxy_config['pass']}@{proxy_config['host']}:{proxy_config['port']}",
            "https": f"http://{proxy_config['user']}:{proxy_config['pass']}@{proxy_config['host']}:{proxy_config['port']}"
        }
        self.headers = {
            "User-Agent": "Mozilla/5.0 (Linux; Android 14; Pixel 8) "
                           "AppleWebKit/537.36 Chrome/121.0.0.0 Mobile Safari/537.36",
            "Accept": "application/json, text/html",
            "Accept-Language": "en-US,en;q=0.9",
            "Referer": "https://www.pinnacle.com/",
            "X-Requested-With": "XMLHttpRequest"
        }
        self.session = requests.Session()
        self.session.proxies = self.proxy
        self.session.headers.update(self.headers)

    def get_sports(self):
        """Get available sports"""
        response = self.session.get(
            "https://guest.api.arcadia.pinnacle.com/0.1/sports",
            timeout=30
        )
        return response.json()

    def get_leagues(self, sport_id):
        """Get leagues for a sport"""
        response = self.session.get(
            f"https://guest.api.arcadia.pinnacle.com/0.1/sports/{sport_id}/leagues",
            timeout=30
        )
        return response.json()

    def get_matchups(self, sport_id, league_id=None):
        """Get events and odds"""
        url = f"https://guest.api.arcadia.pinnacle.com/0.1/sports/{sport_id}/matchups"
        if league_id:
            url += f"?leagueId={league_id}"

        response = self.session.get(url, timeout=30)
        return response.json()

    def get_odds(self, matchup_id):
        """Get detailed odds for a specific event"""
        response = self.session.get(
            f"https://guest.api.arcadia.pinnacle.com/0.1/matchups/{matchup_id}/markets/related/straight",
            timeout=30
        )
        return response.json()

    def scrape_all_football_odds(self):
        """Scrape all football odds"""
        # Football sport_id is typically 29
        matchups = self.get_matchups(sport_id=29)

        all_odds = []
        for matchup in matchups:
            odds = self.get_odds(matchup["id"])
            all_odds.append({
                "event": matchup,
                "odds": odds,
                "scraped_at": datetime.utcnow().isoformat()
            })

            # Respectful rate limiting
            time.sleep(random.uniform(1, 3))

        return all_odds

Sbobet: The Asian Market Leader

Sbobet sets the line for Asian handicap markets and is heavily used by professional bettors in Southeast Asia.

Approach: AJAX Interception

class SbobetScraper:
    def __init__(self, proxy_config):
        self.proxy = {
            "http": f"http://{proxy_config['user']}:{proxy_config['pass']}@{proxy_config['host']}:{proxy_config['port']}",
            "https": f"http://{proxy_config['user']}:{proxy_config['pass']}@{proxy_config['host']}:{proxy_config['port']}"
        }
        self.headers = {
            "User-Agent": "Mozilla/5.0 (Linux; Android 14; Samsung SM-A546B) "
                           "AppleWebKit/537.36 Chrome/121.0.0.0 Mobile Safari/537.36",
            "Accept-Language": "th-TH,th;q=0.9,en;q=0.8",
            "Referer": "https://www.sbobet.com/",
        }

    def scrape_football(self):
        """Scrape Sbobet football odds"""
        session = requests.Session()
        session.proxies = self.proxy
        session.headers.update(self.headers)

        # Load the main page first (establish session cookies)
        session.get("https://www.sbobet.com/", timeout=30)
        time.sleep(random.uniform(2, 4))

        # Access the football section via AJAX endpoint
        response = session.get(
            "https://www.sbobet.com/web-root/restricted/sport/football/today",
            timeout=30
        )

        return self.parse_sbobet_odds(response.text)

    def parse_sbobet_odds(self, html):
        """Parse Sbobet's odds from the response"""
        soup = BeautifulSoup(html, "html.parser")
        events = []

        for row in soup.select(".GameList tr"):
            try:
                teams = row.select(".TeamName")
                odds_cells = row.select(".OddsPrice")

                if teams and odds_cells:
                    event = {
                        "home": teams[0].text.strip() if len(teams) > 0 else None,
                        "away": teams[1].text.strip() if len(teams) > 1 else None,
                        "handicap": self.extract_handicap(row),
                        "odds_home": self.parse_odds(odds_cells[0].text),
                        "odds_away": self.parse_odds(odds_cells[1].text) if len(odds_cells) > 1 else None,
                        "total": self.extract_total(row)
                    }
                    events.append(event)
            except Exception:
                continue

        return events

For Sbobet, a Southeast Asian mobile proxy is essential. Sbobet restricts access based on geographic location and is primarily accessible from Asian IP addresses. DataResearchTools Thai, Indonesian, and Philippine mobile proxies provide the geographic authenticity needed.

Betfair Exchange: Unique Data Source

Betfair is a betting exchange, not a traditional bookmaker. Its odds are set by the market (bettors against each other), making it a unique data source.

Approach: Official API (Preferred)

Betfair offers an official API for data access:

import betfairlightweight

class BetfairScraper:
    def __init__(self, username, password, app_key, proxy_config):
        self.trading = betfairlightweight.APIClient(
            username=username,
            password=password,
            app_key=app_key
        )
        # Configure proxy
        self.trading.session.proxies = {
            "http": f"http://{proxy_config['user']}:{proxy_config['pass']}@{proxy_config['host']}:{proxy_config['port']}",
            "https": f"http://{proxy_config['user']}:{proxy_config['pass']}@{proxy_config['host']}:{proxy_config['port']}"
        }
        self.trading.login()

    def get_football_markets(self):
        """Get all active football markets"""
        event_filter = betfairlightweight.filters.market_filter(
            event_type_ids=["1"],  # Football
            market_type_codes=["MATCH_ODDS", "OVER_UNDER_25"],
            in_play_only=False
        )

        markets = self.trading.betting.list_market_catalogue(
            filter=event_filter,
            max_results=100,
            market_projection=["RUNNER_DESCRIPTION", "MARKET_START_TIME"]
        )

        return markets

    def get_market_odds(self, market_id):
        """Get current odds for a market"""
        price_projection = betfairlightweight.filters.price_projection(
            price_data=["EX_BEST_OFFERS"]
        )

        market_books = self.trading.betting.list_market_book(
            market_ids=[market_id],
            price_projection=price_projection
        )

        return market_books

Data Pipeline Architecture

Real-Time Odds Collection

import asyncio
from datetime import datetime
import json

class OddsPipeline:
    def __init__(self, scrapers, database, alert_system):
        self.scrapers = scrapers
        self.db = database
        self.alerts = alert_system

    async def run(self):
        """Main pipeline loop"""
        while True:
            tasks = []
            for scraper in self.scrapers:
                task = asyncio.create_task(
                    self.scrape_and_store(scraper)
                )
                tasks.append(task)

            results = await asyncio.gather(*tasks, return_exceptions=True)

            # Log results
            for scraper, result in zip(self.scrapers, results):
                if isinstance(result, Exception):
                    self.alerts.send(
                        f"Scraper error for {scraper.name}: {str(result)}"
                    )

            # Wait before next cycle
            await asyncio.sleep(30)  # Adjust based on your needs

    async def scrape_and_store(self, scraper):
        """Scrape odds from one bookmaker and store results"""
        odds_data = await scraper.scrape()
        timestamp = datetime.utcnow()

        records = []
        for event in odds_data:
            for market in event.get("markets", []):
                for selection in market.get("selections", []):
                    record = {
                        "bookmaker": scraper.name,
                        "event_id": event["id"],
                        "event_name": event["name"],
                        "sport": event["sport"],
                        "market_type": market["type"],
                        "selection": selection["name"],
                        "odds": selection["odds"],
                        "timestamp": timestamp
                    }
                    records.append(record)

        await self.db.bulk_insert(records)
        return len(records)

Data Normalization

Every bookmaker presents odds differently. Normalize into a common format:

class OddsNormalizer:
    """Normalize odds data from various bookmakers into standard format"""

    SPORT_MAPPING = {
        # Bet365
        "Soccer": "football",
        "Basketball": "basketball",
        "Tennis": "tennis",
        # Pinnacle
        "Football": "football",
        # Sbobet
        "football": "football",
    }

    MARKET_MAPPING = {
        "1X2": "match_result",
        "MATCH_ODDS": "match_result",
        "MoneyLine": "match_result",
        "Asian Handicap": "asian_handicap",
        "AH": "asian_handicap",
        "Over/Under": "total",
        "OVER_UNDER": "total",
        "O/U": "total",
    }

    def normalize(self, raw_odds, bookmaker):
        """Convert bookmaker-specific format to standard"""
        return {
            "bookmaker": bookmaker,
            "sport": self.SPORT_MAPPING.get(raw_odds.get("sport"), raw_odds.get("sport", "").lower()),
            "league": raw_odds.get("league", ""),
            "event": {
                "home": raw_odds.get("home_team"),
                "away": raw_odds.get("away_team"),
                "start_time": raw_odds.get("start_time"),
            },
            "market": {
                "type": self.MARKET_MAPPING.get(raw_odds.get("market_type"), raw_odds.get("market_type")),
                "line": raw_odds.get("line"),
            },
            "selections": self.normalize_selections(raw_odds),
            "timestamp": datetime.utcnow().isoformat()
        }

    def normalize_selections(self, raw_odds):
        """Normalize selection names and odds values"""
        selections = []
        for sel in raw_odds.get("selections", []):
            selections.append({
                "name": self.clean_selection_name(sel["name"]),
                "odds_decimal": self.to_decimal(sel.get("odds"), sel.get("odds_format", "decimal")),
                "status": sel.get("status", "active")
            })
        return selections

    def to_decimal(self, odds, format_type):
        """Convert any odds format to decimal"""
        if format_type == "decimal":
            return float(odds)
        elif format_type == "american":
            if odds > 0:
                return (odds / 100) + 1
            else:
                return (100 / abs(odds)) + 1
        elif format_type == "hongkong":
            return float(odds) + 1
        elif format_type == "malay":
            if odds >= 0:
                return float(odds) + 1
            else:
                return (1 / abs(float(odds))) + 1
        elif format_type == "indonesian":
            if odds >= 0:
                return float(odds) + 1
            else:
                return (1 / abs(float(odds))) + 1
        return float(odds)

Proxy Rotation Strategy by Bookmaker

Customized Rotation Policies

ROTATION_POLICIES = {
    "bet365": {
        "proxy_type": "mobile",
        "country": "GB",
        "session_type": "sticky",
        "session_duration_minutes": 15,
        "requests_per_session": 30,
        "cooldown_minutes": 10,
        "concurrent_sessions": 1,
        "notes": "Most aggressive anti-bot. Single session, short duration."
    },
    "pinnacle": {
        "proxy_type": "mobile",
        "country": "any",
        "session_type": "rotating",
        "requests_per_ip": 50,
        "cooldown_minutes": 0,
        "concurrent_sessions": 3,
        "notes": "Tolerant of scraping. Can run multiple sessions."
    },
    "sbobet": {
        "proxy_type": "mobile",
        "country": ["TH", "ID", "PH", "MY"],
        "session_type": "sticky",
        "session_duration_minutes": 30,
        "requests_per_session": 40,
        "cooldown_minutes": 5,
        "concurrent_sessions": 2,
        "notes": "Requires SEA IP. DataResearchTools SEA proxies recommended."
    },
    "betfair": {
        "proxy_type": "mobile",
        "country": ["GB", "IE", "AU"],
        "session_type": "sticky",
        "session_duration_minutes": 60,
        "requests_per_session": 100,
        "cooldown_minutes": 0,
        "concurrent_sessions": 2,
        "notes": "API-based. Stable sessions preferred."
    },
    "m88": {
        "proxy_type": "mobile",
        "country": ["TH", "VN", "ID"],
        "session_type": "sticky",
        "session_duration_minutes": 45,
        "requests_per_session": 60,
        "cooldown_minutes": 3,
        "concurrent_sessions": 2,
        "notes": "Standard SEA bookmaker. Moderate protection."
    }
}

Handling Common Scraping Challenges

Challenge 1: Dynamic Content Loading

Many bookmakers load odds asynchronously after the initial page load:

async def wait_for_odds(page, timeout=10000):
    """Wait for odds to appear on the page"""
    try:
        await page.wait_for_selector(
            "[class*='odds'], [class*='price'], [data-odds]",
            timeout=timeout,
            state="visible"
        )
        # Additional wait for all odds to stabilize
        await page.wait_for_timeout(2000)
    except TimeoutError:
        print("Odds did not load within timeout")
        return False
    return True

Challenge 2: Odds Format Differences

Asian bookmakers often display odds in Malay, Hong Kong, or Indonesian format:

Format	Favorite	Underdog	Example
Decimal	1.85	2.10	European standard
American	-118	+110	US standard
Hong Kong	0.85	1.10	HK = Decimal – 1
Malay	0.85	-0.91	Neg = inverse
Indonesian	-1.18	1.10	Inverse of Malay

Challenge 3: Market Matching

The same event appears differently across bookmakers. Matching events requires fuzzy matching:

from fuzzywuzzy import fuzz

def match_events(event_a, event_b, threshold=85):
    """Determine if two events from different bookmakers are the same"""
    # Compare team names
    home_score = fuzz.ratio(
        event_a["home"].lower(),
        event_b["home"].lower()
    )
    away_score = fuzz.ratio(
        event_a["away"].lower(),
        event_b["away"].lower()
    )

    # Check if start times are close (within 5 minutes)
    time_diff = abs(
        (event_a["start_time"] - event_b["start_time"]).total_seconds()
    )
    time_match = time_diff < 300

    # Both team names must match well, and time must be close
    return (home_score >= threshold and
            away_score >= threshold and
            time_match)

Challenge 4: Geographic Restrictions

Some bookmakers are only accessible from specific countries. DataResearchTools mobile proxies solve this by providing genuine mobile IPs from the required regions:

Bookmaker	Accessible Regions	DataResearchTools Coverage
Sbobet	Southeast Asia	Thailand, Indonesia, Philippines, Malaysia, Vietnam
M88	Asia	Full SEA coverage
W88	Asia	Full SEA coverage
Bet365	UK, EU, select others	UK endpoints available
Betfair	UK, Ireland, Australia	UK endpoints available

Monitoring and Maintenance

Health Checks

class ScraperHealthMonitor:
    def __init__(self):
        self.metrics = {}

    def record_scrape(self, bookmaker, success, duration, records_count):
        if bookmaker not in self.metrics:
            self.metrics[bookmaker] = {
                "total_scrapes": 0,
                "successful": 0,
                "failed": 0,
                "avg_duration": 0,
                "total_records": 0
            }

        m = self.metrics[bookmaker]
        m["total_scrapes"] += 1
        if success:
            m["successful"] += 1
            m["total_records"] += records_count
        else:
            m["failed"] += 1

        # Running average
        m["avg_duration"] = (
            (m["avg_duration"] * (m["total_scrapes"] - 1) + duration)
            / m["total_scrapes"]
        )

    def get_health_report(self):
        report = {}
        for bookmaker, m in self.metrics.items():
            success_rate = m["successful"] / max(m["total_scrapes"], 1) * 100
            report[bookmaker] = {
                "success_rate": f"{success_rate:.1f}%",
                "avg_duration": f"{m['avg_duration']:.1f}s",
                "total_records": m["total_records"],
                "status": "healthy" if success_rate > 90 else "degraded" if success_rate > 70 else "failing"
            }
        return report

Conclusion

Scraping betting odds from multiple bookmakers is a complex but achievable task when you combine the right tools. Each bookmaker requires a tailored approach: Bet365 demands full browser automation with UK mobile proxies, Pinnacle offers relatively accessible API-like endpoints, and Asian bookmakers like Sbobet require Southeast Asian mobile IPs.

DataResearchTools mobile proxies provide the geographic coverage and IP quality needed to access bookmakers across both European and Asian markets. Their Southeast Asian carrier network is particularly valuable for scraping the Asian bookmakers that professional bettors rely on for sharp pricing.

Start with the easiest targets (Pinnacle, smaller Asian books), build your normalization pipeline, and then tackle the harder bookmakers as your infrastructure matures. The odds data you collect will power comparison tools, arbitrage detection, market analysis, and predictive models that create genuine competitive advantage in the sports betting ecosystem.

Proxies for Arbitrage Betting: Multi-Account Management Guide

Arbitrage betting, often called “arbing” or “sure betting,” is the practice of placing bets on all possible outcomes of an event across different bookmakers to guarantee a profit regardless of the result. It works because bookmakers occasionally disagree on the probability of outcomes, creating small pricing gaps that can be exploited.

The challenge is that bookmakers actively hunt for arbitrage bettors and will limit or close accounts that display arbing patterns. Managing multiple bookmaker accounts while avoiding detection requires sophisticated proxy infrastructure. This guide explains the entire process.

How Arbitrage Betting Works

The Basic Concept

Arbitrage opportunities arise when the combined implied probability of all outcomes across different bookmakers falls below 100%:

Example: Tennis Match

Outcome	Bookmaker A Odds	Bookmaker B Odds
Player 1 wins	2.10	1.80
Player 2 wins	1.75	2.20

Calculate implied probabilities:

Bookmaker A, Player 1: 1/2.10 = 47.62%
Bookmaker B, Player 2: 1/2.20 = 45.45%
Total: 47.62% + 45.45% = 93.07%

Since the total is below 100%, an arbitrage opportunity exists. The potential profit margin is:

Profit = (1 – 0.9307) x 100 = 6.93%

Stake Calculation

For a total investment of $1,000:

Stake on Player 1 (Bookmaker A at 2.10): $1,000 x (45.45% / 93.07%) = $488.37
Stake on Player 2 (Bookmaker B at 2.20): $1,000 x (47.62% / 93.07%) = $511.63

Outcome	Payout	Profit
Player 1 wins	$488.37 x 2.10 = $1,025.58	$25.58
Player 2 wins	$511.63 x 2.20 = $1,125.59	$125.59

Guaranteed minimum profit: $25.58 on a $1,000 investment.

Why Bookmakers Hate Arbers

Arbitrage bettors extract guaranteed profit from the market without taking any risk. From the bookmaker’s perspective:

Lost margin: Every arb erodes the bookmaker’s theoretical margin.
Sharp money signal: Arb activity often coincides with sharp line movements.
Resource consumption: Arbers make many small, time-sensitive bets that stress systems.
No recreational value: Arbers do not engage with promotions or make losing bets.

Why Proxies Are Essential for Arbitrage Betting

How Bookmakers Detect Arbers

Bookmakers use multiple detection methods:

Detection Method	What They Track	How Proxies Help
IP correlation	Multiple accounts from same IP	Isolate each account to its own proxy
Betting patterns	Consistent arb-sized stakes	Proxies alone do not solve this; behavioral changes needed
Timing analysis	Bets placed simultaneously across books	Proxies add latency variation
Account linking	Shared payment methods, addresses	Not a proxy issue; operational security
Device fingerprinting	Browser, OS, hardware identifiers	Proxy + anti-detect browser needed
Geographic inconsistency	IP location vs. registration address	Geo-targeted proxies solve this

The Multi-Account Requirement

Successful arbitrage betting requires accounts at 10-30+ bookmakers. Many arbers also maintain backup accounts for when primary accounts get limited. Without proxies:

Logging into multiple bookmaker accounts from the same IP links them together
If one account gets flagged, all linked accounts may be investigated
Geographic inconsistencies between your IP and account registration raise flags

Setting Up Proxy Infrastructure for Arbing

Proxy Requirements

Requirement	Why	Solution
Dedicated IP per account	Prevent cross-contamination	Sticky mobile proxy sessions
Geographic matching	IP must match account country	Country-specific proxy endpoints
High uptime	Arbs disappear in seconds	Premium proxy provider with SLA
Low latency	Speed matters for arb execution	Regional proxy servers
Mobile IPs	Highest trust score	Mobile proxy provider

Architecture

[Arb Scanner] --> detects opportunity
      |
      v
[Account Manager] --> selects accounts with best odds
      |
      v
[Proxy Router] --> assigns correct proxy per account
      |
      v
[Bet Placer 1] --proxy A--> [Bookmaker A]
[Bet Placer 2] --proxy B--> [Bookmaker B]
      |
      v
[Confirmation Logger] --> records bet details

Proxy Configuration

class ArbProxyManager:
    def __init__(self):
        self.account_proxies = {}

    def register_account(self, bookmaker, account_id, proxy_config):
        """Permanently assign a proxy to a bookmaker account"""
        key = f"{bookmaker}:{account_id}"
        self.account_proxies[key] = {
            "proxy_url": f"http://{proxy_config['user']}:{proxy_config['pass']}@{proxy_config['host']}:{proxy_config['port']}",
            "country": proxy_config["country"],
            "assigned_at": datetime.now(),
            "last_used": None,
            "request_count": 0
        }

    def get_proxy(self, bookmaker, account_id):
        """Get the assigned proxy for this account"""
        key = f"{bookmaker}:{account_id}"
        proxy_data = self.account_proxies.get(key)

        if not proxy_data:
            raise ValueError(f"No proxy assigned for {key}")

        proxy_data["last_used"] = datetime.now()
        proxy_data["request_count"] += 1

        return proxy_data["proxy_url"]


# Setup example
proxy_manager = ArbProxyManager()

# Each bookmaker account gets its own dedicated proxy
proxy_manager.register_account("bet365", "user_001", {
    "host": "gate.dataresearchtools.com",
    "port": "5001",
    "user": "arb_user_1",
    "pass": "arb_pass_1",
    "country": "GB"
})

proxy_manager.register_account("pinnacle", "user_002", {
    "host": "gate.dataresearchtools.com",
    "port": "5002",
    "user": "arb_user_2",
    "pass": "arb_pass_2",
    "country": "MT"  # Malta, where Pinnacle is licensed
})

proxy_manager.register_account("sbobet", "user_003", {
    "host": "gate.dataresearchtools.com",
    "port": "5003",
    "user": "arb_user_3",
    "pass": "arb_pass_3",
    "country": "TH"  # Thai proxy for Asian bookmaker
})

Multi-Account Management Best Practices

Account Registration

When creating bookmaker accounts for arbing:

Use the proxy from registration onward: The first IP a bookmaker sees becomes part of your account fingerprint. Never register through your home IP.
Match proxy country to your identity documents: If your ID shows a Thai address, use a Thai mobile proxy.
Complete KYC promptly: Delayed KYC can flag an account for review.
Use realistic registration details: Fill in all optional fields (phone, address) to appear legitimate.

Session Management

class BookmakerSession:
    def __init__(self, bookmaker, account_id, proxy_manager):
        self.bookmaker = bookmaker
        self.account_id = account_id
        self.proxy = proxy_manager.get_proxy(bookmaker, account_id)
        self.session = requests.Session()
        self.session.proxies = {
            "http": self.proxy,
            "https": self.proxy
        }
        self.session.headers.update(self.get_headers())

    def get_headers(self):
        """Return consistent headers for this account"""
        # Each account should have a fixed, realistic fingerprint
        return {
            "User-Agent": "Mozilla/5.0 (Linux; Android 14; SM-A546B) "
                           "AppleWebKit/537.36 Chrome/121.0.0.0 Mobile Safari/537.36",
            "Accept-Language": "th-TH,th;q=0.9,en;q=0.8",
            "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9",
        }

    def login(self, username, password):
        """Log into bookmaker through assigned proxy"""
        login_url = self.get_login_url()
        response = self.session.post(login_url, data={
            "username": username,
            "password": password
        })
        return response.status_code == 200

    def place_bet(self, event_id, selection, odds, stake):
        """Place a bet through the assigned proxy"""
        bet_url = self.get_bet_url()
        response = self.session.post(bet_url, json={
            "event_id": event_id,
            "selection": selection,
            "odds": odds,
            "stake": stake
        })
        return response.json()

Behavioral Guidelines

Even with perfect proxy isolation, your betting patterns can expose you:

Bet Sizing

Do not always bet exact arb-calculated stakes (e.g., $487.32)
Round stakes to natural amounts ($490, $500, $485)
Vary your stakes slightly between bets
Occasionally place small recreational bets that are not part of arb strategies

Timing

Do not place both legs of an arb within seconds of each other
Add random delays between bookmaker interactions
Avoid betting exclusively on events where arbs exist
Log in and browse without betting sometimes

Account Activity

Use bookmaker promotions and bonuses (but read the terms carefully)
Place some pre-match bets that look recreational
Engage with the bookmaker’s app or site beyond just betting
Maintain a natural ratio of wins to losses on individual accounts

Anti-Detect Browser Setup

For browser-based bookmaker access, pair your proxy with an anti-detect browser:

Anti-Detect Browser	Key Features	Price Range
Multilogin	Browser profiles, fingerprint management	$99-399/month
GoLogin	Cloud profiles, team sharing	$49-199/month
AdsPower	Free tier available, good for beginners	Free-$50/month
Dolphin Anty	Popular in arb community	$71-239/month

Configuration per profile:

Assign one DataResearchTools mobile proxy per browser profile
Set timezone to match proxy location
Configure language to match proxy country
Use consistent canvas and WebGL fingerprints
Enable cookie persistence between sessions

Finding Arbitrage Opportunities

Manual Scanning

Check odds comparison sites like:

OddsPortal
Oddschecker
BetBrain

Calculate the arb percentage manually or use a spreadsheet formula.

Automated Arb Scanning

class ArbScanner:
    def __init__(self, odds_database):
        self.db = odds_database
        self.min_profit_pct = 1.0  # Minimum 1% profit
        self.max_profit_pct = 15.0  # >15% might be an error

    def find_arbs(self, sport, market_type="1x2"):
        """Scan for arbitrage opportunities"""
        events = self.db.get_active_events(sport)
        arbs = []

        for event in events:
            odds_by_bookmaker = self.db.get_odds(event["id"], market_type)
            arb = self.check_arb(event, odds_by_bookmaker, market_type)
            if arb:
                arbs.append(arb)

        return sorted(arbs, key=lambda x: x["profit_pct"], reverse=True)

    def check_arb(self, event, odds_data, market_type):
        """Check if an arbitrage opportunity exists"""
        if market_type == "1x2":
            selections = ["home", "draw", "away"]
        elif market_type == "moneyline":
            selections = ["home", "away"]
        else:
            return None

        best_odds = {}
        for selection in selections:
            best = max(
                odds_data,
                key=lambda x: x["selections"].get(selection, {}).get("odds", 0)
            )
            best_odds[selection] = {
                "bookmaker": best["bookmaker"],
                "odds": best["selections"][selection]["odds"]
            }

        # Calculate total implied probability
        total_prob = sum(1 / v["odds"] for v in best_odds.values())

        if total_prob < 1.0:
            profit_pct = (1 - total_prob) * 100

            if self.min_profit_pct <= profit_pct <= self.max_profit_pct:
                return {
                    "event": event,
                    "market": market_type,
                    "best_odds": best_odds,
                    "total_probability": total_prob,
                    "profit_pct": round(profit_pct, 2),
                    "found_at": datetime.utcnow().isoformat()
                }

        return None

    def calculate_stakes(self, arb, total_investment):
        """Calculate optimal stakes for each leg"""
        stakes = {}
        total_prob = arb["total_probability"]

        for selection, data in arb["best_odds"].items():
            individual_prob = 1 / data["odds"]
            stake = total_investment * (individual_prob / total_prob)
            stakes[selection] = {
                "bookmaker": data["bookmaker"],
                "odds": data["odds"],
                "stake": round(stake, 2),
                "potential_payout": round(stake * data["odds"], 2)
            }

        return stakes

Arb Execution Workflow

async def execute_arb(arb, stakes, session_manager):
    """Execute an arbitrage bet across multiple bookmakers"""
    results = {}
    tasks = []

    for selection, data in stakes.items():
        session = session_manager.get_session(data["bookmaker"])
        task = asyncio.create_task(
            place_bet_with_retry(
                session=session,
                event_id=arb["event"]["id"],
                selection=selection,
                odds=data["odds"],
                stake=data["stake"],
                min_acceptable_odds=data["odds"] * 0.98  # Accept 2% odds drop
            )
        )
        tasks.append((selection, task))

    # Wait for all bets to complete
    for selection, task in tasks:
        try:
            result = await task
            results[selection] = result
        except Exception as e:
            results[selection] = {"error": str(e)}

    # Check if all legs were successfully placed
    all_success = all(r.get("status") == "confirmed" for r in results.values())

    if not all_success:
        # Handle partial execution (most dangerous scenario)
        handle_partial_arb(arb, results)

    return results


async def place_bet_with_retry(session, event_id, selection, odds, stake, min_acceptable_odds, max_retries=2):
    """Place a bet with retry logic"""
    for attempt in range(max_retries + 1):
        try:
            # Check current odds before placing
            current_odds = await session.get_current_odds(event_id, selection)

            if current_odds < min_acceptable_odds:
                return {"status": "skipped", "reason": "odds moved"}

            result = await session.place_bet(event_id, selection, current_odds, stake)

            if result["status"] == "confirmed":
                return result
            elif result["status"] == "odds_changed":
                continue  # Retry with updated odds
            else:
                return result

        except Exception as e:
            if attempt == max_retries:
                raise
            await asyncio.sleep(0.5)

Risk Management

Partial Execution Risk

The biggest risk in arbing is when one leg gets placed but another fails (odds moved, account limited, site down). Mitigation strategies:

Always check odds immediately before placing: Stale odds are the primary cause of failed arbs.
Set minimum acceptable odds: Reject the bet if odds have moved more than 2% from the scanned value.
Place the less liquid leg first: Start with the bookmaker most likely to move odds or reject the bet.
Have hedging plans: If one leg fails, immediately check if you can hedge on another bookmaker.

Account Limitation Management

When a bookmaker limits your account:

Limitation Type	Impact	Response
Stake limit reduction	Max bet lowered	Scale down arbs on that book
Market restriction	Some markets unavailable	Remove from arb scanner for those markets
Account closure	No more betting	Switch to backup account via different proxy
Withdrawal hold	Funds temporarily locked	Document everything, contact support

Proxy Failure Handling

class ProxyFailoverManager:
    def __init__(self, primary_proxies, backup_proxies):
        self.primary = primary_proxies
        self.backup = backup_proxies
        self.failed_primaries = set()

    def get_proxy(self, account_key):
        if account_key not in self.failed_primaries:
            proxy = self.primary.get(account_key)
            if self.test_proxy(proxy):
                return proxy
            self.failed_primaries.add(account_key)

        # Failover to backup
        return self.backup.get(account_key)

    def test_proxy(self, proxy_url):
        try:
            response = requests.get(
                "https://api.ipify.org",
                proxies={"http": proxy_url, "https": proxy_url},
                timeout=5
            )
            return response.status_code == 200
        except:
            return False

Cost Analysis

Proxy Costs for Arbing

Component	Monthly Cost	Notes
Mobile proxies (10 accounts)	Varies by provider	DataResearchTools offers competitive SEA pricing
Mobile proxies (25 accounts)	Higher volume	Volume discounts typically available
Anti-detect browser	$50-200	GoLogin or Multilogin
Arb scanner software	$50-300	RebelBetting, BetBurger, or custom
VPS for automation	$20-50	Run scanners and placers 24/7

Expected Returns

Monthly Turnover	Average Arb %	Gross Profit	Net After Costs
$10,000	2.5%	$250	Variable
$50,000	2.5%	$1,250	Variable
$100,000	2.0%	$2,000	Variable
$500,000	1.5%	$7,500	Variable

Note: Returns depend heavily on the number of arbs found, execution speed, and account longevity. The proxy investment directly impacts account longevity by reducing detection risk.

Conclusion

Arbitrage betting with proxies is a systematic approach to extracting guaranteed profits from bookmaker pricing inefficiencies. The proxy infrastructure is not optional; it is the foundation that determines how long your accounts survive and how many bookmakers you can operate across simultaneously.

DataResearchTools mobile proxies provide the trust score, geographic targeting, and sticky session capabilities that arbing demands. Their Southeast Asian carrier coverage is particularly valuable for accessing Asian bookmakers like Sbobet, M88, and W88, which frequently offer sharp odds that create arb opportunities with European books.

The key to long-term arbing success is discipline: one proxy per account, geographic consistency, natural betting patterns, and immediate response to account limitations. Invest in quality proxy infrastructure from the start, and you will extend your account lifetimes significantly, which is the single biggest determinant of arbing profitability.

Category: Sports Betting & Odds

How to Scrape Betting Odds from Multiple Bookmakers

How to Scrape Betting Odds from Multiple Bookmakers

Bookmaker Landscape: Know Your Targets

Major International Bookmakers

Asian Bookmakers

Technical Approaches by Bookmaker

Bet365: The Hardest Target

Pinnacle: The Accessible Sharp Book

Sbobet: The Asian Market Leader

Betfair Exchange: Unique Data Source

Data Pipeline Architecture

Real-Time Odds Collection

Data Normalization

Proxy Rotation Strategy by Bookmaker

Customized Rotation Policies

Handling Common Scraping Challenges

Challenge 1: Dynamic Content Loading

Challenge 2: Odds Format Differences

Challenge 3: Market Matching

Challenge 4: Geographic Restrictions

Monitoring and Maintenance

Health Checks

Conclusion

Related Reading

Proxies for Arbitrage Betting: Multi-Account Management Guide

Proxies for Arbitrage Betting: Multi-Account Management Guide

How Arbitrage Betting Works

The Basic Concept

Stake Calculation

Why Bookmakers Hate Arbers

Why Proxies Are Essential for Arbitrage Betting

How Bookmakers Detect Arbers

The Multi-Account Requirement

Setting Up Proxy Infrastructure for Arbing

Proxy Requirements

Architecture

Proxy Configuration

Multi-Account Management Best Practices

Account Registration

Session Management

Behavioral Guidelines

Anti-Detect Browser Setup

Finding Arbitrage Opportunities

Manual Scanning

Automated Arb Scanning

Arb Execution Workflow

Risk Management

Partial Execution Risk

Account Limitation Management

Proxy Failure Handling

Cost Analysis

Proxy Costs for Arbing

Expected Returns

Conclusion

Related Reading