← Todos os guias
Nesta página
Guia Estratégia GTO · 02/08 Apps de solver 15 min Intermediário

Crie análises de pôquer de baixa latência com dados pré-calculados e o solver em tempo real da PokerAI

Leia a estratégia pré-calculada do flop na PokerAI e exiba as frequências de ação assim que ela chegar. Uma mão real de 200NL em pote 3-bet mostra como encontrar um cenário, mudar ações e cartas da mesa e levar os dois ranges para o solver em tempo real no turn e no river.

Atualizado Mantido por Pokerai API

Ao abrir a mão, leia a estratégia atual com /flop/tree e /flop/node. Mostre as frequências assim que a resposta chegar. Quando o usuário escolher uma nova carta, projete os dois ranges pelo caminho de ações e envie um cálculo para aquela street. Mantenha a estratégia anterior visível durante o cálculo.

Quando combinar dados pré-calculados e solver em tempo real

Comece com a estratégia pré-calculada do flop e resolva cada street posterior conforme necessário se o catálogo do Cache não tiver a mão ou se você quiser escolher os ranges ou tamanhos de aposta posteriores. O fluxo está disponível nos planos Free, Starter, Builder e Pro, com as cotas de consultas pré-calculadas e solves de cada plano. É preciso que o cenário do flop esteja disponível.

Projete os dois ranges pelas ações reais e resolva o turn e o river separadamente. O resultado é uma aproximação por street do equilíbrio de Nash da árvore completa de três streets. As estratégias seguintes dependem dos ranges, stacks, tamanhos disponíveis e resultados do solver. Mostre primeiro o flop e acrescente as demais estratégias quando cada cálculo retornar.

Fatos rápidos sobre a mão de 200NL em pote 3-bet

A mão usa o pacote pré-flop 6max_RC_100bb_200NL. MP (posição intermediária) abre e SB (small blind) faz a 3-bet. SB segura A♥K♥ em 4♣8♦9♥. O flop começa com pote de 19 BB e stack efetivo de 91 BB.

Linha de apostas e calls nas três streets
Street e mesaAçãoPróximo passo
Flop4♣ 8♦ 9♥SB aposta 13 BB
MP paga
Sai A♠
TurnA♠SB aposta 14 BB
MP paga
Sai 7♦
River7♦SB aposta 22 BB
MP paga
Showdown
Figura 1. Todas as apostas são pagas e a mão chega ao showdown.

SB aposta 13, 14 e 22 BB nas três streets, e MP paga todas. É a mesma mão do guia da API Cache. No exemplo do solver em tempo real, SB joga fora de posição (OOP) e MP joga em posição (IP).

Encontre um cenário disponível

Envie o pacote pré-flop, o flop e a situação a /availability para verificar se a biblioteca pré-calculada tem a mão. A consulta é gratuita com qualquer chave de API válida.

curl 'https://pokerai.bet/v1/gto/availability' \
  -H "Authorization: Bearer $POKERAI_API_KEY" \
  -H 'Content-Type: application/json' \
  -d '{"type":"flop","request":{"preflop_pack":"6max_RC_100bb_200NL","board":"4c8d9h","pot_type":"3BET","positions":{"raiser":"MP","three_bettor":"SB","hero":"SB"}}}'

Verifique status: "available", match: "exact" e resolved_preflop_pack antes de continuar. Os endpoints de flop existentes podem usar o pacote padrão quando o pacote solicitado não tem o cenário. Para reproduzir a mão, confirme qual pacote foi resolvido antes de permitir a troca da fonte de dados.

Leia a estratégia do flop

Chame /flop/tree no servidor e mantenha a chave de API nele. Use o token do nó raiz em /flop/node e envie hole_cards: "AhKh" para ler a estratégia de A♥K♥.

Fluxo de requisições do pré-cálculo e solver em tempo real
  1. 1. Encontre um cenário disponível/availabilityConsulte a cobertura de graça
  2. 2. Leia e exiba a estratégia/flop/tree e /flop/nodeUma árvore consome uma consulta pré-calculada. A leitura de nós é gratuita.
  3. 3. Projete ranges e calcule/flop/projected-range、/turn/projected-range e /solverEnvie solves separados para turn e river
Figura 2. Mostre o flop primeiro. Calcule as próximas duas streets seguindo as ações e cartas escolhidas.

A requisição lê o nó raiz do flop e usa uma consulta pré-calculada. Consulte as funções post e waitForTree no exemplo completo.

const spot = {
  preflop_pack: "6max_RC_100bb_200NL",
  board: "4c8d9h",
  pot_type: "3BET",
  positions: { hero: "SB", raiser: "MP", three_bettor: "SB" },
};
const hand = "AhKh";
const available = await post("/availability", { type: "flop", request: spot });
if (available.status !== "available" || available.match !== "exact" ||
    available.resolved_preflop_pack !== spot.preflop_pack) {
  throw new Error("This exact presolved Flop spot is not available.");
}
const flop = await post("/flop/tree", { ...spot, hole_cards: hand });
const root = flop.nodes.find((entry) => entry.node === "root" && entry.is_hero);
if (!root?.token) throw new Error("The expected SB root is unavailable.");
const flopStrategy = await post("/flop/node", {
  node: root.token,
  hole_cards: hand,
});

Apresente strategy como frequências de ação e guarde os tokens retornados para leituras posteriores. O campo node: "root" pode identificar o caminho. Nas próximas requisições, envie em node o token correspondente.

Se você já tiver a matriz de estratégia do range completo, selecione a linha correspondente ao mudar de mão. Leia a estratégia de novo ao mudar de nó de ação.

Siga as ações até o turn e o river

No flop SB aposta 13 BB e MP paga. O turn é A♠. SB aposta 14 BB, MP paga novamente e o river é 7♦. Inclua o último call de cada street na projeção para que os ranges reflitam quais mãos do oponente chegam ao call.

Pote e stacks levados à próxima street
Street e mesaPote no início da streetStack efetivo
Flop4♣ 8♦ 9♥19 BB91 BB
TurnA♠45 BB78 BB
River7♦73 BB64 BB
Figura 3. Quando uma aposta é paga, o pote aumenta duas apostas e o stack efetivo cai uma. A tabela usa a linha original. O exemplo usa os tamanhos retornados.

Projete os dois ranges após o call no flop

Use /flop/node para confirmar que o oponente pode pagar. Envie o cenário original e o caminho de ações terminado em /CALL a /flop/projected-range. O endpoint lê os ranges efetivos da árvore pré-calculada e calcula os ranges restantes após a ação.

const action = flopStrategy.strategy.find((row) => row.action === "bet" &&
  !row.allin && row.amount_bb === 13);
const afterBet = flop.nodes.find((entry) => entry.node === "root/BET_13" &&
  !entry.is_hero);
if (!action || !afterBet?.token) throw new Error("The 13 BB Flop branch is unavailable.");
const opponent = await post("/flop/node", { node: afterBet.token });
if (!opponent.actions?.some((row) => row.action === "call")) {
  throw new Error("The Flop call branch is unavailable.");
}
const turnRanges = await post("/flop/projected-range", {
  ...spot,
  node_id: afterBet.node + "/CALL",
  normalize: false,
  bluff_discount_ratio: 1,
});

Leia as combinações ponderadas em range_oop_new_raw e range_ip_new_raw. A projeção usa a mesa da street anterior. Remova todas as combinações bloqueadas pela nova carta antes do cálculo e preserve as restantes com seus pesos. O exemplo usa AhKh apenas para exibição. A projeção e o cálculo usam os dois ranges completos. Se você chamar /v1/gto/range e montar a árvore, comece pelo ranges.effective da árvore do flop.

Envie o cálculo do turn após sair A♠

Envie a /solver a mesa de quatro cartas 4c8d9hAs, os dois ranges filtrados por A♠, o pote e o stack efetivo. O parâmetro público de tamanhos é um percentual inteiro do pote. Nesta medição, 31 produziu uma aposta de 14 BB em um pote de 45 BB. Continue com o tamanho retornado.

if (!turnRanges.range_oop_new_raw || !turnRanges.range_ip_new_raw) {
  throw new Error("Turn ranges are unavailable.");
}
const turnBoard = ["4c", "8d", "9h", "As"];
const turn = await post("/solver", {
  board: turnBoard.join(""),
  oop_range: rangeForBoard(turnRanges.range_oop_new_raw, turnBoard),
  ip_range: rangeForBoard(turnRanges.range_ip_new_raw, turnBoard),
  pot: flop.pot + 2 * action.amount_bb,
  effective_stack: flop.effective_stack - action.amount_bb,
  hero: "OOP",
  bet_sizes: { turn: [31] },
  donk_sizes: { turn: [31] },
});
const turnTree = await waitForTree(turn.solve);
const turnRoot = turnTree.nodes.find((entry) => entry.node === "root" && entry.is_hero);
if (!turnRoot?.token) throw new Error("The expected Turn root is unavailable.");
const turnStrategy = await post("/solver/node", {
  node: turnRoot.token,
  hole_cards: hand,
});
if (!Array.isArray(turnStrategy.strategy)) throw new Error("Turn strategy is unavailable.");

Envie o cálculo do river após o call no turn

Chame /turn/projected-range com o identificador do cálculo do turn e o caminho da ação. Árvores calculadas em tempo real usam caminhos como root/BET 14.000000. Acrescente /CALL ao caminho retornado. Remova as combinações que contêm 7♦ dos dois ranges e envie um novo cálculo com 4c8d9hAs7d.

const selected = await selectBetCall(turnTree, turnStrategy, 14);
const riverRanges = await post("/turn/projected-range", {
  solve: turn.solve,
  node_id: selected.entry.node + "/CALL",
  normalize: false,
  bluff_discount_ratio: 1,
});
if (!riverRanges.range_oop_new_raw || !riverRanges.range_ip_new_raw) {
  throw new Error("River ranges are not ready.");
}
const riverBoard = [...turnBoard, "7d"];
const river = await post("/solver", {
  board: riverBoard.join(""),
  oop_range: rangeForBoard(riverRanges.range_oop_new_raw, riverBoard),
  ip_range: rangeForBoard(riverRanges.range_ip_new_raw, riverBoard),
  pot: Number((turnTree.pot + 2 * selected.bb).toFixed(2)),
  effective_stack: Number((turnTree.effective_stack - selected.bb).toFixed(2)),
  hero: "OOP",
  bet_sizes: { river: [30] },
  donk_sizes: { river: [30] },
});
const riverTree = await waitForTree(river.solve);
const riverRoot = riverTree.nodes.find((entry) => entry.node === "root" && entry.is_hero);
if (!riverRoot?.token) throw new Error("The expected River root is unavailable.");
const riverStrategy = await post("/solver/node", {
  node: riverRoot.token,
  hole_cards: hand,
});
if (!Array.isArray(riverStrategy.strategy)) throw new Error("River strategy is unavailable.");
const showDown = await selectBetCall(riverTree, riverStrategy, 22);
console.log({ turn: selected.bb, river: showDown.bb });

A aposta original no river foi de 22 BB. Os tamanhos do exemplo retornaram esse ramo na medição. Exiba o valor e as frequências devolvidas pelo solver. Depois do call que leva ao showdown, chame /solver/release quando terminar a última leitura.

Mantenha a estratégia visível durante o cálculo

Exiba a estratégia junto com o estado do cálculo. Quando o usuário escolher turn ou river, mantenha a estratégia anterior enquanto a nova é calculada. Consulte /solver/tree com o identificador original até spot_status: "queryable" e chame /solver/node com o token retornado.

Deixe o usuário escolher quando tentar novamente após 429 busy. Encerre a espera em no_nodes, error ou expired. Se a submissão expirar e o resultado for desconhecido, preserve a tela para evitar outra submissão com consumo de cota. Ao mudar a ação ou a mesa, use o contexto da requisição para ignorar respostas atrasadas da seleção anterior.

Tempos das requisições e cotas

Os 0,077479 s do flop incluem a leitura da árvore pré-calculada e do nó. Os 2,258036 s do turn foram contados a partir da submissão corrigida. A projeção anterior dos ranges do flop foi medida à parte e levou 0,079021 s. Os 2,190538 s do river começam na projeção dos ranges do turn e incluem submissão, consultas de status e leitura do nó. As barras do Cache representam leituras individuais de estratégia para a mesma mão.

Tempos das requisições de estratégia nas três streets Mesma mão de 200NL em pote 3-bet · escala comum (segundos)
FluxoTempoRodada
Flop4♣ 8♦ 9♥
Estratégia do Cache4,425 sA
Endpoints existentes0,077 sD
TurnA♠
Estratégia do Cache1,348 sB
Endpoints existentes2,258 sE
River7♦
Estratégia do Cache1,319 sC
Endpoints existentes2,191 sE
Medições do Cache · 18 de novembro, horário de Hong Kong A Raiz do flop, 13:37–13:38 B Carta do turn, 17:44–17:45 C Carta do river, 20:52 Medições com os endpoints existentes · 19 de novembro, horário de Hong Kong D Leitura pré-calculada do flop, 09:51 E Solves do turn e river, 09:53
Figura 4. As barras azuis são leituras individuais de estratégia da medição do Cache da mesma mão. As barras laranja correspondem aos endpoints existentes. O texto explica o início de cada medição. Os fluxos foram medidos em rodadas diferentes.
Operação da API Cota consumida
Verificar o cenário em /availability 0
Ler uma árvore pré-calculada com /flop/tree 1 consulta pré-calculada
Ler um nó comum de flop ou solver com token válido 0
Projetar os ranges do flop com /flop/projected-range 1 consulta pré-calculada
Iniciar um cálculo de turn ou river com /solver 1 solve por novo cálculo
Consultar /solver/tree, projetar ranges do turn ou liberar o cálculo 0

O exemplo usa duas consultas pré-calculadas e até dois solves nas três streets. Caso um cálculo idêntico seja devolvido diretamente, consulte o comprovante solve_quota. As leituras de nós comuns e as consultas de status reutilizam o token ou identificador original.

Execute o exemplo completo

Mantenha as posições, as cartas da mão, a mesa e o caminho de ações juntos. Mostre a estratégia do flop quando carregar e trate carregamento e erros no turn e no river separadamente. Reutilize uma submissão em andamento quando mesa, ranges, pote, stack efetivo e tamanhos forem iguais.

Coloque as funções auxiliares abaixo antes dos quatro blocos JavaScript acima e execute em um módulo ES do Node.js. Executar o exemplo com a API de produção consome a cota da conta.

const API = "https://pokerai.bet/v1/gto";
const key = process.env.POKERAI_API_KEY;
if (!key) throw new Error("Set POKERAI_API_KEY on your backend.");

async function post(path, body, timeoutMs = 15_000) {
  const response = await fetch(API + path, {
    method: "POST",
    headers: { Authorization: `Bearer ${key}`, "Content-Type": "application/json" },
    body: JSON.stringify(body),
    signal: AbortSignal.timeout(timeoutMs),
  });
  const payload = await response.json();
  if (!response.ok) throw new Error(`${path}: HTTP ${response.status} (${payload.error ?? payload.status ?? "unknown"})`);
  return payload;
}

function rangeForBoard(range, board) {
  const blocked = new Set(board);
  const combos = range.split(",").map((item) => item.trim()).filter((item) => {
    const match = /^([2-9TJQKA][cdhs])([2-9TJQKA][cdhs]):([0-9.]+(?:e[+-]?\d+)?)$/i.exec(item);
    if (!match || !Number.isFinite(Number(match[3]))) {
      throw new Error("Invalid weighted combo in the projected range.");
    }
    const canonical = (card) => card[0].toUpperCase() + card[1].toLowerCase();
    const first = canonical(match[1]);
    const second = canonical(match[2]);
    if (first === second) throw new Error("Duplicate card in a projected combo.");
    return !blocked.has(first) && !blocked.has(second);
  });
  if (!combos.length) throw new Error("No legal combinations for the next board.");
  return combos.join(",");
}

async function selectBetCall(tree, strategy, targetBb) {
  const bets = tree.nodes.flatMap((entry) => {
    const match = /^root\/BET (\d+(?:\.\d+)?)$/.exec(entry.node);
    return match && !entry.is_hero && entry.token ? [{ entry, bb: Number(match[1]) }] : [];
  });
  const selected = bets.sort((a, b) => Math.abs(a.bb - targetBb) - Math.abs(b.bb - targetBb))[0];
  if (!selected || Math.abs(selected.bb - targetBb) > 0.5 ||
      !strategy.strategy.some((row) => row.action === "bet" && !row.allin &&
        Math.abs(row.amount_bb - selected.bb) < 0.02)) {
    throw new Error(`No supported bet sizing close to ${targetBb} BB.`);
  }
  const opponent = await post("/solver/node", { node: selected.entry.token });
  if (!opponent.actions?.some((row) => row.action === "call")) {
    throw new Error("The call branch is unavailable.");
  }
  return selected;
}

async function waitForTree(solve, deadlineMs = 90_000) {
  if (typeof solve !== "string" || !solve) throw new Error("Missing solve handle.");
  const deadline = Date.now() + deadlineMs;
  while (Date.now() < deadline) {
    const tree = await post("/solver/tree", { solve }, Math.min(10_000, deadline - Date.now()));
    if (tree.spot_status === "queryable") return tree;
    if (!["available", "computing"].includes(tree.spot_status)) {
      throw new Error(`Solve stopped: ${tree.spot_status ?? "missing status"}`);
    }
    const delay = Math.min(1_000, deadline - Date.now());
    if (delay > 0) await new Promise((resolve) => setTimeout(resolve, delay));
  }
  throw new Error("Solve polling timed out. Keep the original handle.");
}

Medições e reprodução

A mão e o caminho de ações vêm de uma captura da API Cache em produção de 18 de novembro de 2026. Requisições HTTPS públicas aos endpoints existentes em 19 de novembro confirmaram o mesmo pacote, a mesma mão e as três apostas pagas de 13, 14 e 22 BB. Os dois solves iniciaram novos cálculos. O teste usou duas consultas pré-calculadas e dois solves.

O primeiro envio do turn retornou invalid_range e não consumiu cota de solve. O range da street anterior ainda incluía A♠. A filtragem das combinações bloqueadas permitiu concluir os cálculos no caminho original. O gráfico identifica cada rodada de medição. As cartas públicas e as ações permaneceram iguais durante a projeção e a filtragem.

Ao citar os resultados, inclua o pacote de estratégia, a mesa, o caminho de ações, a data e o método de medição. O guia é para treino, pesquisa e revisão depois da sessão. Análise em tempo real aqui significa explorar cenários interativamente em uma ferramenta. A assistência em tempo real em mesas de dinheiro real é proibida.

Documentação da API · Referência da API · Fluxo do solver em tempo real · OpenAPI · llms.txt

Com Builder ou Pro e um cenário disponível na íntegra no Cache, leia a estratégia na mesma árvore pré-calculada à medida que as ações e cartas mudam. O guia complementar usa a mesma mão de 200NL em pote 3-bet para mostrar a consulta gratuita de cobertura, a estratégia das três streets e a leitura de EV e equidade sob demanda. Crie um produto de análise de pôquer em tempo real e com baixa latência com a API Cache da PokerAI