Gestão de Banca: Critério de Kelly e Stake
95% dos apostadores quebram — e não é por falta de análise. É por falta de gestão de banca. Neste artigo, você aprende o Critério de Kelly, compara
O problema número 1 não é análise — é gestão
95% dos apostadores quebram — e não é por falta de análise. É por falta de gestão de banca. Neste artigo, você aprende o Critério de Kelly, compara com flat betting, e constrói um simulador em Python.
95% quebram — e não é por falta de informação
Galera, vou ser direto: o motivo pelo qual a grande maioria dos apostadores perde dinheiro não tem nada a ver com saber ou não saber de futebol. Não é falta de modelo estatístico. Não é falta de dados. É falta de gestão de banca.
O cenário típico é assim: a pessoa começa com R$ 1.000 de banca. Encontra uma aposta que parece boa com odd 2.50. Aposta R$ 200 — 20% da banca. Perde. Fica nervosa. A próxima aposta parece ainda melhor. Aposta R$ 300 pra recuperar. Perde de novo. Em duas semanas, a banca acabou.
O problema não era a qualidade das apostas. O problema era o tamanho delas. Se a pessoa tivesse apostado R$ 30 em cada uma — 3% da banca — teria sobrevivido facilmente a uma sequência de perdas e estaria no jogo pra quando as vitórias viessem. Sobrevivência é condição necessária pra lucro.
A gestão de banca é a diferença entre um apostador recreativo que perde dinheiro se divertindo e um apostador que trata isso como investimento. E o Critério de Kelly é o framework matemático mais robusto que existe pra definir o tamanho ideal de cada aposta.
Critério de Kelly: a fórmula
O Critério de Kelly foi criado por John Kelly no Bell Labs em 1956. A ideia original era otimizar apostas em corridas de cavalos baseado em informações de insiders transmitidas por linhas telefônicas. Sim, a história real é exatamente tão doida quanto parece.
A fórmula é simples: f* = (bp - q) / b, onde f* é a fração da banca que você deve apostar, b é a odd decimal menos 1 (o lucro líquido por unidade apostada), p é a probabilidade real de ganhar (sua estimativa), e q é a probabilidade de perder (1 - p).
Exemplo prático
Digamos que você acha que o Flamengo tem 60% de chance de ganhar, e a odd oferecida é 2.00. Então: b = 2.00 - 1 = 1.00, p = 0.60, q = 0.40. Kelly = (1.00 x 0.60 - 0.40) / 1.00 = 0.20. O Kelly diz pra apostar 20% da banca.
Parece muito, né? E é. O Kelly puro é agressivo demais na prática. A maioria dos apostadores profissionais usa o meio Kelly (metade do valor sugerido) ou até um quarto do Kelly. No exemplo acima, meio Kelly seria 10% — ainda agressivo — e um quarto seria 5%, que é muito mais razoável.
def kelly_criterion(prob_win, odds_decimal, fraction=1.0):
"""Calcula a fração da banca para apostar usando Kelly.
Args:
prob_win: probabilidade estimada de ganhar (0 a 1)
odds_decimal: odd decimal oferecida pela casa
fraction: fração do Kelly (1.0 = full, 0.5 = half, 0.25 = quarter)
Returns:
dict com stake recomendado e métricas
"""
b = odds_decimal - 1 # lucro líquido por unidade
q = 1 - prob_win
kelly = (b * prob_win - q) / b
# Kelly negativo = sem edge, não apostar
if kelly <= 0:
return {
'stake_percent': 0,
'edge': round((prob_win * odds_decimal - 1) * 100, 2),
'has_value': False,
'message': 'Sem edge. Não apostar.'
}
adjusted_kelly = kelly * fraction
edge = (prob_win * odds_decimal - 1) * 100 # edge em %
return {
'stake_percent': round(adjusted_kelly * 100, 2),
'full_kelly': round(kelly * 100, 2),
'edge': round(edge, 2),
'has_value': True,
'ev_per_bet': round(edge * adjusted_kelly, 4), # EV como % da banca
}
# Exemplos
print('=== Cenário 1: Value bet claro ===')
result = kelly_criterion(prob_win=0.60, odds_decimal=2.00, fraction=0.5)
print(f"Stake (meio Kelly): {result['stake_percent']}% da banca")
print(f"Edge: {result['edge']}%")
print('\n=== Cenário 2: Edge pequeno ===')
result = kelly_criterion(prob_win=0.55, odds_decimal=1.90, fraction=0.25)
print(f"Stake (1/4 Kelly): {result['stake_percent']}% da banca")
print(f"Edge: {result['edge']}%")
print('\n=== Cenário 3: Sem edge ===')
result = kelly_criterion(prob_win=0.45, odds_decimal=2.00, fraction=0.5)
print(f"Resultado: {result['message']}")
print(f"Edge: {result['edge']}%")A beleza do Kelly é que ele automaticamente ajusta o stake ao tamanho do edge. Edge grande? Aposta mais. Edge pequeno? Aposta pouco. Sem edge? Não aposta. Essa proporcionalidade é o que maximiza o crescimento no longo prazo segundo a teoria da informação.
Flat vs Kelly vs Proporcional
Existem três estratégias principais de sizing de aposta. Cada uma tem trade-offs diferentes entre crescimento, risco e simplicidade. Vou explicar as três e depois mostrar na simulação qual performa melhor.
Flat Betting
Aposta o mesmo valor fixo em todas as apostas, independente do edge ou da odd.
+ Prós
- • Simples — não precisa calcular nada além de escolher a aposta
- • Protege contra erros de estimativa de probabilidade
- • Variância baixa — drawdowns são mais previsíveis
- • Bom pra quem está começando e ainda não confia no modelo
− Contras
- • Não maximiza crescimento — trata value bets fortes igual aos fracos
- • Não ajusta ao tamanho da banca — se a banca cresce, o stake fica proporcionalmente menor
- • Subótimo matematicamente no longo prazo
Critério de Kelly
Ajusta o stake proporcionalmente ao edge estimado de cada aposta.
+ Prós
- • Maximiza crescimento logarítmico da banca no longo prazo
- • Automaticamente aposta mais quando tem mais edge
- • Nunca recomenda apostar quando não tem edge (Kelly negativo)
- • Base matemática sólida — comprovado pela teoria da informação
− Contras
- • Kelly puro é agressivo — drawdowns podem chegar a 50%+
- • Depende de estimativa precisa de probabilidade — erro no p destrói tudo
- • Meio Kelly ou quarto Kelly perdem parte da vantagem teórica
- • Mais complexo de implementar e manter disciplina
Proporcional (% fixo da banca)
Aposta sempre o mesmo percentual da banca atual (ex: 3%).
+ Prós
- • Ajusta automaticamente ao tamanho da banca — cresce quando ganha, diminui quando perde
- • Impossível quebrar completamente (matematicamente)
- • Simples de implementar
- • Meio-termo entre flat e Kelly em termos de crescimento
− Contras
- • Não diferencia apostas com edge grande de edge pequeno
- • Percentual fixo pode ser muito alto pra apostas sem edge
- • Crescimento mais lento que Kelly quando o modelo é preciso
Minha recomendação: comece com flat betting enquanto valida seu modelo. Depois migre pra quarto de Kelly quando tiver confiança na calibração das probabilidades. Nunca use Kelly puro — a variância é grande demais pro mundo real, onde seu modelo tem erros que você nem sabe que existem.
Simulador de Monte Carlo em Python
Teoria é bonita, mas ver os números em ação é outra coisa. Vamos construir um simulador que roda milhares de cenários e mostra a distribuição de resultados pra cada estratégia de gestão de banca.
import numpy as np
import matplotlib.pyplot as plt
from dataclasses import dataclass
@dataclass
class Bet:
prob_win: float # probabilidade real de ganhar
odds: float # odd decimal oferecida
edge: float # edge calculado
def simulate_bankroll(
bets: list[Bet],
initial_bankroll: float,
strategy: str = 'kelly_quarter',
flat_stake: float = 50,
prop_pct: float = 0.03,
n_simulations: int = 10000,
):
"""Simula evolução da banca com Monte Carlo."""
n_bets = len(bets)
final_bankrolls = []
max_drawdowns = []
for _ in range(n_simulations):
bankroll = initial_bankroll
peak = bankroll
max_dd = 0
history = [bankroll]
for bet in bets:
if bankroll <= 0:
break
# Define stake pela estratégia
if strategy == 'flat':
stake = min(flat_stake, bankroll)
elif strategy == 'proportional':
stake = bankroll * prop_pct
elif strategy == 'kelly_full':
k = kelly_criterion(bet.prob_win, bet.odds)
stake = bankroll * (k['stake_percent'] / 100)
elif strategy == 'kelly_half':
k = kelly_criterion(bet.prob_win, bet.odds, fraction=0.5)
stake = bankroll * (k['stake_percent'] / 100)
elif strategy == 'kelly_quarter':
k = kelly_criterion(bet.prob_win, bet.odds, fraction=0.25)
stake = bankroll * (k['stake_percent'] / 100)
else:
stake = bankroll * 0.02
stake = max(0, stake)
# Resultado da aposta (simulado)
won = np.random.random() < bet.prob_win
if won:
bankroll += stake * (bet.odds - 1)
else:
bankroll -= stake
# Drawdown
peak = max(peak, bankroll)
dd = (peak - bankroll) / peak if peak > 0 else 0
max_dd = max(max_dd, dd)
history.append(bankroll)
final_bankrolls.append(bankroll)
max_drawdowns.append(max_dd)
return {
'strategy': strategy,
'mean_final': round(np.mean(final_bankrolls), 2),
'median_final': round(np.median(final_bankrolls), 2),
'p5': round(np.percentile(final_bankrolls, 5), 2),
'p95': round(np.percentile(final_bankrolls, 95), 2),
'bust_rate': round(sum(1 for b in final_bankrolls if b < 10) / n_simulations * 100, 1),
'mean_max_drawdown': round(np.mean(max_drawdowns) * 100, 1),
'final_bankrolls': final_bankrolls,
}
# Gera 500 apostas simuladas com edge positivo médio de 5%
np.random.seed(42)
bets = [
Bet(
prob_win=0.50 + np.random.uniform(0.02, 0.08),
odds=round(np.random.uniform(1.80, 2.50), 2),
edge=0 # calculado depois
)
for _ in range(500)
]
for b in bets:
b.edge = (b.prob_win * b.odds - 1) * 100
print('Simulação: 500 apostas, banca inicial R$ 1.000')
print('=' * 60)
for strat in ['flat', 'proportional', 'kelly_quarter', 'kelly_half', 'kelly_full']:
result = simulate_bankroll(bets, 1000, strategy=strat, n_simulations=5000)
print(f"\n{strat.upper()}:")
print(f" Banca final média: R$ {result['mean_final']}")
print(f" Banca final mediana: R$ {result['median_final']}")
print(f" Range 5-95%: R$ {result['p5']} - R$ {result['p95']}")
print(f" Taxa de ruína: {result['bust_rate']}%")
print(f" Drawdown máximo médio: {result['mean_max_drawdown']}%")A simulação mostra um padrão consistente: Kelly puro tem a maior média de banca final, mas também a maior taxa de ruína e o maior drawdown. Kelly de um quarto tem crescimento decente com risco controlado. Flat betting tem o menor risco mas o menor crescimento. Proporcional fica no meio.
O detalhe matador: olhe pra mediana, não pra média. A média é distorcida por poucos cenários onde o Kelly puro deu muito certo. A mediana mostra o resultado que a maioria das simulações teve. E aí o quarto de Kelly costuma ser o mais equilibrado.
Disciplina e automação
O melhor sistema de gestão de banca do mundo é inútil se você não segue ele. E aí é que a automação entra. Quando o cálculo do stake é manual, a emoção interfere. Você vê uma aposta que parece certeza e coloca mais do que devia. Ou perde três seguidas e reduz o stake pra proteger a banca — exatamente quando o Kelly diz pra manter.
A solução: tire a decisão de tamanho de aposta da sua mão. O código calcula, você executa. Melhor ainda: integre o Kelly com o bot de Telegram pra que a mensagem de alerta já venha com o stake recomendado. Assim você recebe: 'VALUE BET — Flamengo x Palmeiras — Casa: Bet365 — Odd: 2.15 — Edge: 4.2% — Stake recomendado: R$ 38 (3.8% da banca)'. Pronto. Decisão tomada sem emoção.
Checklist de gestão de banca profissional
- Banca separada do dinheiro pessoal — nunca misture
- Tamanho da banca definido como valor que pode perder inteiramente sem impacto na vida
- Estratégia de sizing escolhida e documentada (recomendo Kelly 1/4 pra começar)
- Planilha ou banco de dados com registro de cada aposta: data, jogo, odd, stake, resultado, banca atual
- Revisão mensal: taxa de acerto, ROI, CLV médio, drawdown máximo
- Stop-loss mensal definido: se perder X% da banca no mês, para e reavalia o modelo
- Automação do cálculo de stake — o código decide, você executa
- Nunca aumentar stake pra recuperar perdas (anti-martingale)
Um último ponto que pouca gente fala: o maior risco não é uma sequência de perdas. É overconfidence. Quando você ganha 15 apostas seguidas, a tentação de aumentar o stake além do que o Kelly recomenda é enorme. Não faça isso. O Kelly já leva em conta o edge. Se o edge é 5%, o Kelly diz 5% (ou 1.25% no quarto de Kelly). Não importa se você acertou as últimas 50 — o edge da próxima aposta não mudou.
Construa o sistema completo de apostas com dados
Gestão de banca é uma peça do sistema. Combine com os modelos de Poisson, ELO e xG do artigo de análise estatística, visualize tudo no dashboard de React, e receba alertas prontos pelo bot de Telegram. Na CrazyStack, você aprende a construir sistemas completos com código real — não só teoria.