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.
/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.
| Street e mesa | Ação | Pró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 |
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♥.
- 1. Encontre um cenário disponível
/availabilityConsulte a cobertura de graça - 2. Leia e exiba a estratégia
/flop/treee/flop/nodeUma árvore consome uma consulta pré-calculada. A leitura de nós é gratuita. - 3. Projete ranges e calcule
/flop/projected-range、/turn/projected-rangee/solverEnvie solves separados para turn e river
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.
| Street e mesa | Pote no início da street | Stack efetivo |
|---|---|---|
| Flop4♣ 8♦ 9♥ | 19 BB | 91 BB |
| TurnA♠ | 45 BB | 78 BB |
| River7♦ | 73 BB | 64 BB |
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.
| Fluxo | Tempo | Rodada | |
|---|---|---|---|
| Flop4♣ 8♦ 9♥ | |||
| Estratégia do Cache | 4,425 s | A | |
| Endpoints existentes | 0,077 s | D | |
| TurnA♠ | |||
| Estratégia do Cache | 1,348 s | B | |
| Endpoints existentes | 2,258 s | E | |
| River7♦ | |||
| Estratégia do Cache | 1,319 s | C | |
| Endpoints existentes | 2,191 s | E | |
| 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
Leia as três streets diretamente quando houver cache completo
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