Web Scraping de Sites de Apostas com Python —

pip install playwright beautifulsoup4 pandas
playwright install chromium

from playwright.sync_api import sync_playwright
import json

def setup_browser():
    """Configura browser com stealth settings."""
    pw = sync_playwright().start()
    browser = pw.chromium.launch(
        headless=True,
        args=[
            "--disable-blink-features=AutomationControlled",
            "--disable-features=IsolateOrigins,site-per-process"
        ]
    )
    context = browser.new_context(
        viewport={"width": 1920, "height": 1080},
        user_agent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
        locale="pt-BR",
        timezone_id="America/Sao_Paulo"
    )
    
    # Remove sinais de automação
    context.add_init_script("""
        Object.defineProperty(navigator, 'webdriver', {get: () => undefined});
        window.chrome = { runtime: {} };
    """)
    
    return pw, browser, context

def scrape_via_network_intercept(url: str, api_pattern: str):
    """Captura dados interceptando requests de API interna."""
    pw, browser, context = setup_browser()
    captured_data = []
    
    def handle_response(response):
        """Callback pra cada response de rede."""
        if api_pattern in response.url and response.status == 200:
            try:
                data = response.json()
                captured_data.append(data)
            except Exception:
                pass
    
    page = context.new_page()
    page.on("response", handle_response)
    
    page.goto(url, wait_until="networkidle")
    page.wait_for_timeout(5000)  # espera dados carregarem
    
    browser.close()
    pw.stop()
    
    return captured_data

# Uso: intercepta a API interna do site
# dados = scrape_via_network_intercept(
#     "https://site-de-apostas.com/futebol",
#     "/api/odds"  # padrão da URL da API interna
# )

from bs4 import BeautifulSoup

def scrape_via_html(url: str, odds_selector: str):
    """Coleta odds parseando o HTML renderizado."""
    pw, browser, context = setup_browser()
    page = context.new_page()
    
    page.goto(url, wait_until="networkidle")
    page.wait_for_selector(odds_selector, timeout=15000)
    
    html = page.content()
    soup = BeautifulSoup(html, "html.parser")
    
    # Exemplo genérico — seletores dependem do site
    games = []
    for event in soup.select(".event-row"):
        teams = event.select(".team-name")
        odds = event.select(".odds-value")
        
        if len(teams) >= 2 and len(odds) >= 3:
            games.append({
                "home": teams[0].text.strip(),
                "away": teams[1].text.strip(),
                "home_odds": float(odds[0].text.strip()),
                "draw_odds": float(odds[1].text.strip()),
                "away_odds": float(odds[2].text.strip())
            })
    
    browser.close()
    pw.stop()
    return games

def scrape_via_websocket(url: str):
    """Captura dados de WebSocket pra odds ao vivo."""
    pw, browser, context = setup_browser()
    ws_messages = []
    
    def handle_ws(ws):
        def on_message(msg):
            try:
                data = json.loads(msg)
                ws_messages.append(data)
            except (json.JSONDecodeError, TypeError):
                pass
        ws.on("framereceived", lambda payload: on_message(payload))
    
    page = context.new_page()
    page.on("websocket", handle_ws)
    
    page.goto(url, wait_until="networkidle")
    page.wait_for_timeout(30000)  # coleta 30 segundos de dados
    
    browser.close()
    pw.stop()
    
    return ws_messages

import random
import time

def human_delay(min_sec=1.5, max_sec=5.0):
    """Simula delay humano entre ações."""
    delay = random.uniform(min_sec, max_sec)
    time.sleep(delay)

def random_scroll(page):
    """Simula scroll humano — anti-bots verificam isso."""
    scroll_amount = random.randint(200, 600)
    page.mouse.wheel(0, scroll_amount)
    human_delay(0.5, 1.5)

def navigate_humanly(page, url: str):
    """Navega pro URL simulando comportamento humano."""
    page.goto(url, wait_until="domcontentloaded")
    human_delay(2, 4)
    random_scroll(page)
    human_delay(1, 3)
    random_scroll(page)
    page.wait_for_load_state("networkidle")

import re
from datetime import datetime

TEAM_ALIASES = {
    "São Paulo FC": "São Paulo",
    "SPFC": "São Paulo",
    "Sao Paulo": "São Paulo",
    "SE Palmeiras": "Palmeiras",
    "CR Flamengo": "Flamengo",
    # ... adicione conforme necessário
}

def clean_team_name(raw: str) -> str:
    """Normaliza nome do time."""
    cleaned = re.sub(r'\s+', ' ', raw).strip()
    return TEAM_ALIASES.get(cleaned, cleaned)

def clean_odds(raw: str) -> float | None:
    """Converte odds de string pra float com validação."""
    try:
        odds = float(raw.replace(',', '.'))
        if 1.01 <= odds <= 100:
            return odds
        return None  # fora do range válido
    except (ValueError, AttributeError):
        return None

def clean_scraped_data(raw_games: list) -> list:
    """Pipeline de limpeza completo."""
    cleaned = []
    for game in raw_games:
        home = clean_team_name(game.get("home", ""))
        away = clean_team_name(game.get("away", ""))
        home_odds = clean_odds(str(game.get("home_odds", "")))
        draw_odds = clean_odds(str(game.get("draw_odds", "")))
        away_odds = clean_odds(str(game.get("away_odds", "")))
        
        if home and away and home_odds and away_odds:
            cleaned.append({
                "home": home,
                "away": away,
                "home_odds": home_odds,
                "draw_odds": draw_odds,
                "away_odds": away_odds,
                "scraped_at": datetime.now().isoformat()
            })
    
    return cleaned