Arbitragem em apostas esportivas: como
Arbitragem em apostas — o famoso surebet — é apostar em todos os resultados possíveis em casas diferentes e garantir lucro independente do resultado. Dá pra automatizar a
Por que isso é importante
Arbitragem em apostas — o famoso surebet — é apostar em todos os resultados possíveis em casas diferentes e garantir lucro independente do resultado. Dá pra automatizar a detecção com Python. Veja como.
Galera, arbitragem em apostas é um dos poucos casos onde a matemática garante lucro independente do resultado — pelo menos na teoria. Na prática, a coisa tem nuances importantes. Aqui vou explicar como funciona, como calcular e como automatizar a detecção com Python.
Aviso padrão: conteúdo educacional e técnico. Não é incentivo a apostas. Verifique as leis do seu país e os termos das casas antes de qualquer aplicação.
O que é surebet — arbitragem em apostas
Surebet acontece quando odds de casas diferentes cobrem todos os resultados possíveis de um evento com lucro garantido, independente do que acontecer. Por que isso ocorre? Porque cada casa de apostas define suas odds de forma independente. Quando há discrepância grande o suficiente entre duas ou mais casas, surge a oportunidade de arbitragem.
Exemplo: num jogo com dois resultados possíveis, a Casa A oferece odd 2.10 para o time 1 e a Casa B oferece odd 2.10 para o time 2. Se você apostar R$ 100 em cada, ganha R$ 210 num caso e perde R$ 100 no outro — lucro líquido de R$ 10 garantido. Simples assim no conceito.
A matemática da arbitragem
A condição de arbitragem é verificada calculando o overround combinado. Se a soma dos inversos das melhores odds entre todas as casas for menor que 1, existe surebet. Quanto menor essa soma, maior o lucro percentual.
# Python 3.11+
# surebet_math.py — matemática da arbitragem
def verificar_arbitragem_2_outcomes(
odd1: float,
odd2: float
) -> dict:
"""
Verifica arbitragem entre 2 outcomes (ex: tênis, basquete).
Args:
odd1: melhor odd disponível para outcome 1
odd2: melhor odd disponível para outcome 2
Returns:
Dict com análise da arbitragem
"""
# Soma dos inversos das odds
soma = (1 / odd1) + (1 / odd2)
tem_arbitragem = soma < 1.0
lucro_pct = (1 / soma - 1) * 100 if tem_arbitragem else 0
return {
"tem_arbitragem": tem_arbitragem,
"soma_inversos": round(soma, 6),
"lucro_percentual": round(lucro_pct, 4),
"odd1": odd1,
"odd2": odd2,
}
def verificar_arbitragem_3_outcomes(
odd_home: float,
odd_draw: float,
odd_away: float
) -> dict:
"""
Verifica arbitragem em mercado 1X2 (futebol).
"""
soma = (1 / odd_home) + (1 / odd_draw) + (1 / odd_away)
tem_arbitragem = soma < 1.0
lucro_pct = (1 / soma - 1) * 100 if tem_arbitragem else 0
return {
"tem_arbitragem": tem_arbitragem,
"soma_inversos": round(soma, 6),
"lucro_percentual": round(lucro_pct, 4),
}
def calcular_stakes_arbitragem(
odds: list[float],
banca_total: float
) -> list[dict]:
"""
Calcula quanto apostar em cada outcome para garantir lucro.
Args:
odds: lista com as melhores odds de cada outcome
banca_total: valor total a distribuir entre as apostas
Returns:
Lista com stake e retorno para cada outcome
"""
soma_inversos = sum(1 / o for o in odds)
retorno_garantido = banca_total / soma_inversos
lucro = retorno_garantido - banca_total
stakes = []
for odd in odds:
stake = retorno_garantido / odd
stakes.append({
"odd": odd,
"stake": round(stake, 2),
"retorno_se_ganhar": round(stake * odd, 2),
})
print(f"Banca total: R$ {banca_total:.2f}")
print(f"Retorno garantido: R$ {retorno_garantido:.2f}")
print(f"Lucro garantido: R$ {lucro:.2f} ({lucro/banca_total*100:.2f}%)")
return stakes
# Exemplo: jogo de futebol com oportunidade de arbitragem
print("=== Verificação de Arbitragem ===")
# Casa A: odd 2.10 no time 1, Casa B: odd 1.95 no empate, Casa C: odd 2.30 no time 2
result = verificar_arbitragem_3_outcomes(2.10, 1.95, 2.30)
print(f"Tem arbitragem: {result['tem_arbitragem']}")
print(f"Soma inversos: {result['soma_inversos']}")
print(f"Lucro: {result['lucro_percentual']}%")
if result["tem_arbitragem"]:
print("\n=== Stakes para R$ 1000 ===")
stakes = calcular_stakes_arbitragem([2.10, 1.95, 2.30], 1000)
for s in stakes:
print(f" Odd {s['odd']}: apostar R$ {s['stake']} -> retorno R$ {s['retorno_se_ganhar']}")Como encontrar surebets manualmente
Manualmente, o processo é: você abre comparadores de odds como OddsPortal ou Oddschecker, encontra um evento com odds altas em casas diferentes para resultados distintos, e aplica a fórmula da soma dos inversos. Se for menor que 1, é surebet.
Na prática, fazer isso manualmente é lento e ineficiente. As oportunidades surgem e somem em minutos — as casas monitoram o mercado e ajustam as odds rapidamente. Por isso, automação é quase obrigatória pra quem leva arbitragem a sério.
Automatizando a detecção com Python
O detector precisa: coletar odds de várias casas para o mesmo evento, identificar a melhor odd disponível por outcome, aplicar o cálculo de arbitragem, e alertar quando encontra uma oportunidade. A fonte de dados pode ser API (ideal) ou scraping.
# Python 3.11+
# surebet_detector.py — detector automatizado de arbitragem
from dataclasses import dataclass, field
from collections import defaultdict
@dataclass
class SurebetOportunidade:
evento_id: str
home_team: str
away_team: str
commence_time: str
soma_inversos: float
lucro_percentual: float
melhor_odd_home: dict
melhor_odd_draw: dict | None
melhor_odd_away: dict
def encontrar_melhores_odds(
evento: dict
) -> dict[str, dict]:
"""
Para cada outcome de um evento, encontra a melhor odd
disponível entre todas as bookmakers.
Args:
evento: dict no formato The Odds API
Returns:
Dict outcome -> {bookmaker, odd}
"""
melhores: dict[str, dict] = {}
for bookmaker in evento.get("bookmakers", []):
for market in bookmaker.get("markets", []):
if market["key"] != "h2h":
continue
for outcome in market.get("outcomes", []):
nome = outcome["name"]
odd = outcome["price"]
if nome not in melhores or odd > melhores[nome]["odd"]:
melhores[nome] = {
"bookmaker": bookmaker["key"],
"odd": odd,
"outcome": nome,
}
return melhores
def detectar_surebets(
eventos: list[dict],
lucro_minimo_pct: float = 0.5 # 0.5% de lucro mínimo
) -> list[SurebetOportunidade]:
"""
Detecta oportunidades de arbitragem numa lista de eventos.
Args:
eventos: lista de eventos com odds (formato The Odds API)
lucro_minimo_pct: lucro mínimo em % para reportar
"""
oportunidades = []
for evento in eventos:
melhores = encontrar_melhores_odds(evento)
home_team = evento["home_team"]
away_team = evento["away_team"]
# Tentativa de arbitragem em 1X2
outcomes_1x2 = [home_team, "Draw", away_team]
if all(o in melhores for o in outcomes_1x2):
odds_vals = [melhores[o]["odd"] for o in outcomes_1x2]
soma = sum(1 / o for o in odds_vals)
if soma < 1.0:
lucro_pct = (1 / soma - 1) * 100
if lucro_pct >= lucro_minimo_pct:
oportunidades.append(SurebetOportunidade(
evento_id=evento["id"],
home_team=home_team,
away_team=away_team,
commence_time=evento.get("commence_time", ""),
soma_inversos=round(soma, 6),
lucro_percentual=round(lucro_pct, 4),
melhor_odd_home=melhores[home_team],
melhor_odd_draw=melhores.get("Draw"),
melhor_odd_away=melhores[away_team]
))
# Arbitragem em H2H (sem empate: tênis, basquete, etc.)
elif home_team in melhores and away_team in melhores:
odd_h = melhores[home_team]["odd"]
odd_a = melhores[away_team]["odd"]
soma = 1/odd_h + 1/odd_a
if soma < 1.0:
lucro_pct = (1 / soma - 1) * 100
if lucro_pct >= lucro_minimo_pct:
oportunidades.append(SurebetOportunidade(
evento_id=evento["id"],
home_team=home_team,
away_team=away_team,
commence_time=evento.get("commence_time", ""),
soma_inversos=round(soma, 6),
lucro_percentual=round(lucro_pct, 4),
melhor_odd_home=melhores[home_team],
melhor_odd_draw=None,
melhor_odd_away=melhores[away_team]
))
return sorted(oportunidades, key=lambda x: x.lucro_percentual, reverse=True)
# Uso do detector
if __name__ == "__main__":
# eventos = fetch_odds(sport="soccer_brazil_campeonato")
# oportunidades = detectar_surebets(eventos)
# for op in oportunidades:
# print(f"{op.home_team} x {op.away_team}: {op.lucro_percentual}% de lucro")
print("Detector de surebets pronto para uso")Riscos e limitações reais
Arbitragem não é dinheiro grátis. Os riscos são reais e precisam ser entendidos antes de qualquer coisa. O maior risco é o tempo: entre você detectar a surebet e executar as apostas nas duas casas, a odd pode ter mudado. Se uma das odds cair antes de você apostar, a arbitragem deixa de existir — e você pode ficar com uma aposta unilateral de alto risco.
O segundo risco é o bloqueio de conta. Casas de apostas são explícitas sobre isso: elas fecham contas de apostadores que identificam como arbers. Não é questão de se, é questão de quando. A maioria dos arbers profissionais tem contas em dezenas de casas e as usa com frequência limitada pra não levantar suspeitas.
Riscos que você precisa conhecer
Odds mudam rápido: latência entre detecção e execução pode invalidar a oportunidade
Casas fecham contas de arbers — é uma corrida contra o relógio de médio prazo
Apostas canceladas unilateralmente deixam você exposto num dos lados
Limites de apostas baixos nas casas limitam o lucro por oportunidade
Capital precisa estar distribuído em várias casas simultaneamente
Ferramentas de surebet existentes
Existem ferramentas prontas que fazem a detecção pra você. Pra quem está aprendendo a lógica técnica, construir do zero é o caminho certo. Pra quem quer operar de verdade, as ferramentas comerciais têm feeds de dados mais rápidos e algoritmos mais sofisticados.
RebelBetting
Uma das ferramentas mais populares para value betting e arbitragem. Interface limpa, alertas em tempo real e suporte a dezenas de bookmakers.
OddsMonkey
Focado inicialmente em matched betting, mas tem módulo de arbitragem. Popular no Reino Unido. Inclui calculadoras e tutoriais.
BetBurger
Agregador de surebets com dados de mais de 70 bookmakers. Tem plano básico acessível. UI um pouco datada mas dados são bons.
The Odds API
Para quem quer construir o próprio detector. A API mais popular entre devs. Agrega 40+ bookmakers com histórico de odds.
No final, construir o próprio detector tem valor educacional enorme e te dá controle total. Mas pra operar em escala real, as ferramentas comerciais têm infraestrutura que é difícil de replicar — feeds de dados sub-segundo, suporte a dezenas de casas em simultâneo e alertas por app. Você decide o que faz mais sentido pro seu objetivo.
Antes de começar com arbitragem de verdade
- Entenda completamente a matemática — use a fórmula até ela ser automática
- Comece com apostas pequenas enquanto aprende a executar rápido
- Tenha contas em pelo menos 5-8 bookmakers diferentes
- Calcule o lucro por hora realista — muitas oportunidades valem centavos
- Tenha capital distribuído nas contas antes de começar
- Aceite que as contas vão ser limitadas ou fechadas eventualmente