APIs de odds para apostas: as melhores

# Python 3.11+
# Exemplo completo de request na The Odds API

import requests
import os
from pprint import pprint

API_KEY = os.getenv("ODDS_API_KEY")
BASE_URL = "https://api.the-odds-api.com/v4"


def get_sports() -> list[dict]:
    """Lista todos os esportes disponíveis."""
    resp = requests.get(
        f"{BASE_URL}/sports",
        params={"apiKey": API_KEY},
        timeout=10
    )
    resp.raise_for_status()
    return resp.json()


def get_odds(
    sport: str,
    regions: str = "eu",
    markets: str = "h2h,totals",
    bookmakers: str | None = None
) -> list[dict]:
    """
    Busca odds atuais para um esporte.
    
    Parâmetros:
    - regions: eu (Europa), uk, us, au
    - markets: h2h (1x2), spreads, totals, outrights
    - bookmakers: lista separada por vírgula (opcional)
    """
    params = {
        "apiKey": API_KEY,
        "regions": regions,
        "markets": markets,
        "oddsFormat": "decimal",
        "dateFormat": "iso",
    }
    if bookmakers:
        params["bookmakers"] = bookmakers
    
    resp = requests.get(f"{BASE_URL}/sports/{sport}/odds", params=params, timeout=15)
    resp.raise_for_status()
    
    print(f"Requests usados: {resp.headers.get('x-requests-used', '?')}")
    print(f"Requests restantes: {resp.headers.get('x-requests-remaining', '?')}")
    
    return resp.json()


# Uso real
if __name__ == "__main__":
    odds = get_odds(
        sport="soccer_brazil_campeonato",
        regions="eu",
        markets="h2h"
    )
    print(f"\n{len(odds)} jogos encontrados")
    if odds:
        pprint(odds[0])  # mostra o primeiro evento

# Python 3.11+
# Autenticação básica na BetFair API
# Requer conta BetFair e certificado TLS

import requests
import json

BETFAIR_ENDPOINT = "https://api.betfair.com/exchange/betting/json-rpc/v1"
LOGIN_URL = "https://identitysso-cert.betfair.com/api/certlogin"


def betfair_login(username: str, password: str, app_key: str) -> str:
    """
    Autentica na BetFair e retorna o session token.
    Requer certificado TLS em /path/to/client-2048.crt e .key
    """
    resp = requests.post(
        LOGIN_URL,
        data={"username": username, "password": password},
        headers={"X-Application": app_key, "Content-Type": "application/x-www-form-urlencoded"},
        cert=("/path/to/client-2048.crt", "/path/to/client-2048.key"),
        timeout=10
    )
    data = resp.json()
    if data.get("loginStatus") != "SUCCESS":
        raise ValueError(f"Login falhou: {data.get('loginStatus')}")
    return data["sessionToken"]


def list_events(session_token: str, app_key: str, event_type_id: str = "1") -> list[dict]:
    """
    Lista eventos disponíveis.
    event_type_id: 1=futebol, 2=tênis, 4=cricket, etc.
    """
    body = {
        "jsonrpc": "2.0",
        "method": "SportsAPING/v1.0/listEvents",
        "params": {
            "filter": {"eventTypeIds": [event_type_id]}
        }
    }
    resp = requests.post(
        BETFAIR_ENDPOINT,
        data=json.dumps(body),
        headers={
            "X-Application": app_key,
            "X-Authentication": session_token,
            "Content-Type": "application/json"
        },
        timeout=15
    )
    return resp.json().get("result", [])

# Python 3.11+
# odds_client.py — cliente genérico com retry e rate limiting

import time
import requests
from functools import wraps
from typing import Callable


def retry_on_error(max_retries: int = 3, delay: float = 1.0):
    """Decorator para retry automático em erros de rede."""
    def decorator(func: Callable):
        @wraps(func)
        def wrapper(*args, **kwargs):
            last_exc = None
            for attempt in range(max_retries):
                try:
                    return func(*args, **kwargs)
                except requests.exceptions.RequestException as e:
                    last_exc = e
                    if attempt < max_retries - 1:
                        wait = delay * (2 ** attempt)  # exponential backoff
                        print(f"Tentativa {attempt + 1} falhou. Aguardando {wait}s...")
                        time.sleep(wait)
            raise last_exc
        return wrapper
    return decorator


class OddsAPIClient:
    """Cliente para The Odds API com rate limiting integrado."""
    
    BASE_URL = "https://api.the-odds-api.com/v4"
    
    def __init__(self, api_key: str, requests_per_second: float = 2.0):
        self.api_key = api_key
        self.min_interval = 1.0 / requests_per_second
        self._last_request = 0.0
        self.session = requests.Session()
    
    def _throttle(self) -> None:
        """Garante intervalo mínimo entre requests."""
        elapsed = time.time() - self._last_request
        if elapsed < self.min_interval:
            time.sleep(self.min_interval - elapsed)
        self._last_request = time.time()
    
    @retry_on_error(max_retries=3)
    def get_odds(self, sport: str, **params) -> list[dict]:
        """Busca odds com throttling e retry automático."""
        self._throttle()
        resp = self.session.get(
            f"{self.BASE_URL}/sports/{sport}/odds",
            params={"apiKey": self.api_key, "oddsFormat": "decimal", **params},
            timeout=15
        )
        resp.raise_for_status()
        return resp.json()


# Uso
# client = OddsAPIClient(api_key=os.getenv("ODDS_API_KEY"))
# odds = client.get_odds("soccer_brazil_campeonato", regions="eu", markets="h2h")