Documentação · Lightning Baccarat

API do Lightning Baccarat

Rodadas da mesa Lightning Baccarat da Evolution: cartas do Player e do Banker, pontuação, quem ganhou, pares e naturais. Sem os multiplicadores do Lightning. Esta página mostra como a API do Lightning Baccarat responde, com os campos explicados um a um.

https://api.lynxmetrics.com/v1/lightning-baccarat

Ver o Lightning Baccarat ao vivo

Ver em Markdown

Autenticação

Envie no cabeçalho x-api-key uma chave criada no painel para o Lightning Baccarat, já que a chave de outra API recebe key_wrong_api.

curl https://api.lynxmetrics.com/v1/lightning-baccarat/latest \
  -H "x-api-key: SUA_CHAVE"

Chaves, teste e assinaturas (você pode assinar a mesma API várias vezes, cada uma com as suas chaves) funcionam igual em todas as APIs e estão explicados na documentação geral.

Exemplos de código

Exemplos prontos para copiar, em Python, Node.js e PHP. Troque SUA_CHAVE pela chave do painel e rode: cada um chama a função on_round (onRound no Node.js) a cada rodada nova do Lightning Baccarat, e é nela que entra o seu código.

Tempo real pelo stream (recomendado)

Uma conexão aberta que recebe cada rodada no instante em que ela fecha. Só a abertura da conexão gasta requisição, então você não esbarra no limite por minuto, e é o caminho que entrega mais rápido. O exemplo reconecta sozinho, manda o last-event-id para receber em missed o que fechou enquanto esteve fora, e para quando chega closed.

import json
import time
import requests

API = "https://api.lynxmetrics.com/v1/lightning-baccarat"
KEY = "SUA_CHAVE"


def on_round(r):
    print(r["id"], r["outcome"], r["data"])


def listen():
    last_id = None
    while True:
        headers = {"x-api-key": KEY, "accept": "text/event-stream"}
        if last_id:
            headers["last-event-id"] = last_id
        try:
            with requests.get(API + "/stream", headers=headers, stream=True, timeout=(10, 60)) as res:
                if res.status_code != 200:
                    print("HTTP", res.status_code, res.text)
                    time.sleep(int(res.headers.get("retry-after", 10)))
                    continue
                res.encoding = "utf-8"
                event, data = None, []
                for line in res.iter_lines(chunk_size=1, decode_unicode=True):
                    if line.startswith("event:"):
                        event = line[6:].strip()
                    elif line.startswith("data:"):
                        data.append(line[5:].strip())
                    elif line == "":
                        if event and data:
                            body = json.loads("\n".join(data))
                            if event == "ready":
                                for r in body.get("missed") or []:
                                    on_round(r)
                                if body.get("data"):
                                    last_id = body["data"]["id"]
                            elif event == "round":
                                on_round(body["data"])
                                last_id = body["data"]["id"]
                            elif event == "closed":
                                return
                        event, data = None, []
        except requests.RequestException as error:
            print("reconnecting:", error)
        time.sleep(3)


listen()

Latest com espera (sem conexão aberta)

Para quem prefere pedir em vez de manter uma conexão aberta. O ?wait=20 segura a resposta até a próxima rodada do Lightning Baccarat fechar, por no máximo 20 segundos, então a rodada chega no instante em que fecha e o exemplo faz poucas requisições por minuto em vez de perguntar a toda hora. Ele manda o ETag da última resposta em if-none-match: enquanto nada muda, a espera termina em 304 sem corpo, e no 429 ele espera o tempo do cabeçalho retry-after em vez de insistir.

import time
import requests

API = "https://api.lynxmetrics.com/v1/lightning-baccarat"

session = requests.Session()
session.headers["x-api-key"] = "SUA_CHAVE"


def on_round(r):
    print(r["id"], r["outcome"], r["data"])


etag = None
last_id = None
while True:
    try:
        res = session.get(
            API + "/latest",
            params={"wait": 20},
            headers={"if-none-match": etag} if etag else {},
            timeout=30,
        )
    except requests.RequestException as error:
        print("retrying:", error)
        time.sleep(5)
        continue

    if res.status_code == 200:
        etag = res.headers.get("etag")
        r = res.json()["data"]
        if r and r["id"] != last_id:
            if last_id:
                on_round(r)
            last_id = r["id"]
    elif res.status_code == 429:
        time.sleep(int(res.headers.get("retry-after", 5)))
        continue
    elif res.status_code != 304:
        print("HTTP", res.status_code, res.text)
        time.sleep(10)
        continue
    time.sleep(2)

Mandar cada rodada para o Telegram

Troque a função on_round de qualquer um dos exemplos acima por esta, com o token do seu bot (o que o @BotFather entrega) e o id do chat ou do canal. O outcome e tudo o que vem em data estão explicados mais abaixo, em Campos de cada rodada.

BOT_TOKEN = "123456:ABC..."
CHAT_ID = "-1001234567890"


def on_round(r):
    text = f"{r['outcome'].upper()} · {r['id']}"
    requests.post(
        f"https://api.telegram.org/bot{BOT_TOKEN}/sendMessage",
        json={"chat_id": CHAT_ID, "text": text},
        timeout=10,
    )

O que mais dá problema em bot

  • Não consulte mais rápido do que a mesa joga. Com menos de 1 segundo entre as consultas você só gasta o limite e recebe 429: a rodada nova não chega antes por isso. Se precisa do resultado no mesmo segundo, use o /stream.
  • No 429, leia o cabeçalho retry-after e espere esse tempo, porque repetir na hora não adianta. Toda resposta traz x-ratelimit-remaining e x-ratelimit-reset, que dizem quanto ainda cabe no minuto.
  • 401 em toda chamada quer dizer chave errada, revogada ou trocada no painel: copie a chave de novo. Muitas tentativas seguidas com chave inválida fazem o seu IP receber 429 por um tempo, mesmo depois de corrigir.
  • trial_expired quer dizer que as horas do teste acabaram. Assinando um plano no painel, a mesma chave volta a funcionar, sem mexer no código.
  • Se o seu bot ficou parado, não tente adivinhar o que perdeu: peça /results?after= com o id da última rodada que você tem e receba, em ordem, todas as que fecharam depois.
  • Cada chave tem um número de conexões de stream, na tabela de limites. Passou disso, a conexão mais antiga é encerrada com closed. Para rodar vários bots, crie uma chave para cada um no painel.

GET /v1/lightning-baccarat/latest

A rodada mais recente do Lightning Baccarat, ou null se ainda não houver nenhuma.

  • waitnumber

    Segundos que a resposta pode esperar pela próxima rodada, até 20. Só espera quem já tem a última: mande o ETag dela em if-none-match ou o id dela em after. Quando uma rodada fecha, a resposta sai na hora com ela; se o tempo acabar antes, vem 304 (com ETag) ou a mesma rodada (com after). Conta como uma requisição só, e o tempo limite do seu cliente tem de ser maior que o wait.

  • afterid

    O id da última rodada que você tem. Só serve junto com wait, para quem não guarda o ETag.

Resposta

{
  "data": {
    "id": "v1793314712000",
    "game": "lightning-baccarat",
    "tableId": "LightningBac0001",
    "startedAt": "2026-10-29T22:58:36.000Z",
    "settledAt": "2026-10-29T22:59:02.000Z",
    "outcome": "banker",
    "data": {
      "player": {
        "cards": ["QH", "TH", "QD"],
        "score": 0,
        "pair": false
      },
      "banker": { "cards": ["AS", "6H"], "score": 7, "pair": false },
      "natural": false
    }
  }
}

GET /v1/lightning-baccarat/results

Rodadas do Lightning Baccarat da mais nova para a mais antiga. Para buscar a página seguinte, passe o nextCursor da resposta em before, e quando ele vier null não há mais resultados.

  • limitnumber

    Quantas rodadas trazer, com padrão 50 e máximo 250 a 1000.

  • beforeISO 8601

    Traz só rodadas encerradas antes desta data, como o nextCursor da página anterior, e até onde dá para voltar depende do plano.

  • afterISO 8601 | id

    Para sincronizar sem repetir nem pular rodadas: passe o settledAt ou o id da última rodada que você já tem, e a resposta traz só as encerradas depois dela, da mais antiga para a mais nova, até o limit. Se a página vier cheia, o nextCursor vai no próximo after, e quando ele vier null você está em dia. Também respeita o histórico do plano e pode ser usado junto com before.

GET /v1/lightning-baccarat/results?limit=1

{
  "data": [
    {
      "id": "v1793314712000",
      "game": "lightning-baccarat",
      "tableId": "LightningBac0001",
      "startedAt": "2026-10-29T22:58:36.000Z",
      "settledAt": "2026-10-29T22:59:02.000Z",
      "outcome": "banker",
      "data": {
        "player": {
          "cards": ["QH", "TH", "QD"],
          "score": 0,
          "pair": false
        },
        "banker": { "cards": ["AS", "6H"], "score": 7, "pair": false },
        "natural": false
      }
    }
  ],
  "nextCursor": "2026-10-29T22:59:02.000Z"
}

GET /v1/lightning-baccarat/stream

Rodadas do Lightning Baccarat ao vivo, numa conexão que fica aberta (SSE, Server-Sent Events): cada rodada chega no instante em que é salva, sem você ficar perguntando. É o caminho mais rápido, porque tira o intervalo entre as suas consultas. É HTTP comum, então atravessa proxy e CDN e funciona com qualquer cliente que aceite cabeçalho e leitura contínua.

curl -N https://api.lynxmetrics.com/v1/lightning-baccarat/stream \
  -H "x-api-key: SUA_CHAVE" \
  -H "accept: text/event-stream"

Resposta

event: round
data: {
data:   "data": {
data:     "id": "v1793314712000",
data:     "game": "lightning-baccarat",
data:     "tableId": "LightningBac0001",
data:     "startedAt": "2026-10-29T22:58:36.000Z",
data:     "settledAt": "2026-10-29T22:59:02.000Z",
data:     "outcome": "banker",
data:     "data": {
data:       "player": {
data:         "cards": ["QH", "TH", "QD"],
data:         "score": 0,
data:         "pair": false
data:       },
data:       "banker": { "cards": ["AS", "6H"], "score": 7, "pair": false },
data:       "natural": false
data:     }
data:   },
data:   "timing": {
data:     "receivedAt": "2026-10-29T22:59:05.900Z",
data:     "sentAt": "2026-10-29T22:59:05.950Z"
data:   }
data: }

O que chega na conexão

  • readyevent

    Vem uma só vez, assim que a conexão abre, com a última rodada já encerrada, para você começar em dia. Não é rodada nova: compare o id com o da última que você tem e não conte duas vezes. O data vem null enquanto não houver nenhuma rodada. Numa reconexão ele traz também, em missed, as rodadas que fecharam enquanto você estava fora.

  • phaseopcional

    Opcional: só chega se você pedir com ?phases=1. São dois avisos por rodada, ambos com ref, game, phase, at e sentAt: betting, quando a mesa volta ao plano aberto e as apostas da próxima rodada abrem, e resolving, quando ela entra na resolução e as apostas já fecharam — este leva também o roundId, o id que a rodada vai ter no round, vários segundos antes do resultado. Para saber a que rodada um resultado pertence você NÃO precisa disto: bastam o id do round, a ordem garantida e o last-event-id. A fase serve para amarrar mais cedo, e não é promessa de resultado — um close-up cortado, uma falha na transmissão ou uma leitura insegura fazem a rodada ser descartada de propósito, e aí nenhum round vem com aquele ref.

  • roundevent

    Uma por rodada nova, com o mesmo objeto que o /latest devolve em data, os horários da entrega em timing e, quando a rodada teve fase, o ref dela. O id do evento é o id da rodada, e só o round tem id, porque é ele que serve de ponto de retomada na reconexão.

  • correctionopcional

    Opcional: só chega se você pedir com ?corrections=1. Avisa que uma rodada que já tinha saído no round mudou: no Bac Bo, cerca de uma vez a cada 2.000 rodadas a mesa repete a jogada de um copinho depois de os dados terem parado, e o dado que saiu deixa de valer. Vem com data, a rodada como ela fica (o mesmo id e os mesmos horários), previous, com o outcome e o data que tinham sido entregues, e sentAt. Não leva id de evento, então o last-event-id não muda. Chega quando aquela rodada termina na mesa, de 30 segundos a 3 minutos depois do round. Mesmo sem pedir, o /latest, o /results e o /stats passam a devolver a rodada corrigida.

  • gapevent

    A fila desta conexão estourou e rodadas foram descartadas: o seu cliente não estava dando conta do ritmo. Vem com resyncError: too_many_missed, o mesmo código da reconexão que ficou longa. A conexão continua aberta, e é este o único caso em que falta rodada no meio de um stream — sempre anunciado, porque os ids não são sequenciais e você não teria como notar. Para fechar o buraco, peça /results?after= com o id da última rodada que você recebeu.

  • closedevent

    A sua conexão foi encerrada porque outra mais nova foi aberta com a mesma chave. Vem com reason: "replaced". Não é queda de rede, então não reconecte automaticamente: reconectar aqui só derrubaria a conexão nova, que então reconectaria e derrubaria a sua, sem fim.

  • : pingcomentário

    A cada 20 segundos sem rodada vai uma linha começando com dois-pontos. Não é evento e pode ser ignorada; ela só impede que algum proxy no meio feche a conexão parada.

Amarrar um palpite antes do fecho

O id de uma rodada é o próprio instante em que as apostas fecharam, ao milissegundo: ele não existe enquanto elas estão abertas, e não há como adivinhá-lo. Para quem publica um palpite antes do fecho existe o ref, uma referência nossa, criada na abertura das apostas e repetida na resolução e no resultado. Carimbe o palpite com o ref do betting e case com o round que trouxer o mesmo ref, sem depender da ordem de chegada e sem esperar o id. Peça as fases com ?phases=1; quem conecta no meio já recebe a fase em que a mesa está.

A mesma rodada, da abertura das apostas até o resultado

event: phase
data: {
data:   "ref": "r1761939000000-7",
data:   "game": "lightning-baccarat",
data:   "phase": "betting",
data:   "at": "2026-10-29T22:58:36.000Z",
data:   "sentAt": "2026-10-29T22:58:36.100Z"
data: }

event: phase
data: {
data:   "ref": "r1761939000000-7",
data:   "roundId": "v1793314712000",
data:   "game": "lightning-baccarat",
data:   "phase": "resolving",
data:   "at": "2026-10-29T22:58:52.840Z",
data:   "sentAt": "2026-10-29T22:58:55.000Z"
data: }

event: round
data: {
data:   "data": {
data:     "id": "v1793314712000",
data:     "game": "lightning-baccarat",
data:     "tableId": "LightningBac0001",
data:     "startedAt": "2026-10-29T22:58:36.000Z",
data:     "settledAt": "2026-10-29T22:59:02.000Z",
data:     "outcome": "banker",
data:     "data": {
data:       "player": {
data:         "cards": ["QH", "TH", "QD"],
data:         "score": 0,
data:         "pair": false
data:       },
data:       "banker": { "cards": ["AS", "6H"], "score": 7, "pair": false },
data:       "natural": false
data:     }
data:   },
data:   "ref": "r1761939000000-7",
data:   "timing": {
data:     "receivedAt": "2026-10-29T22:59:05.900Z",
data:     "sentAt": "2026-10-29T22:59:05.950Z"
data:   }
data: }
  • refstring

    A referência da rodada, igual nos três eventos. É uma cadeia opaca: não tente interpretá-la nem derivar dela a próxima. Um ref pode ficar sem resultado — se a rodada for descartada, nenhum round chega com ele, e o betting seguinte abre outra.

  • roundIdstring

    O id definitivo da rodada. Só aparece a partir do resolving, porque é ancorado no instante do fecho das apostas. É ele que vem no id do evento round e serve de last-event-id na reconexão.

  • phasebetting | resolving

    betting: as apostas da próxima rodada abriram. resolving: a mesa entrou na resolução e as apostas fecharam. Teste sempre este campo em vez de supor, porque fases novas podem ser acrescentadas.

  • atISO 8601

    Instante da fase no relógio da mesa, o mesmo de startedAt e settledAt. O sentAt, ao lado, é quando o aviso saiu na sua conexão.

Horários e atraso

Os eventos carregam os horários de cada pedaço do caminho, para você medir o atraso real em vez de estimar. Os horários da rodada estão no relógio da mesa; os da entrega, no relógio da nossa API. O atraso do Lightning Baccarat é medido contra a mesa e aparece nos próprios carimbos de cada evento, rodada por rodada.

  • data.startedAtISO 8601

    Início da rodada no relógio da mesa, que é quando as apostas abriram.

  • data.settledAtISO 8601

    Fim da rodada no relógio da mesa: o instante em que o resultado ficou definido na origem. É também a data usada na ordenação, no before e no after.

  • timing.receivedAtISO 8601

    Quando o resultado ficou pronto aqui, do nosso lado. A diferença entre ele e o settledAt é o atraso da origem até nós, que é a parte que está nas nossas mãos.

  • timing.sentAtISO 8601

    Quando este evento foi escrito na sua conexão. A diferença entre ele e o receivedAt é o tempo que a rodada esperou na fila desta conexão, normalmente alguns milissegundos; o resto do atraso até o seu código é rede.

Reconectar sem perder rodada

Ao reconectar, mande no cabeçalho last-event-id o id da última rodada que você recebeu — um cliente de SSE que reconecta sozinho já manda esse cabeçalho, e quem controla a reconexão manda o cabeçalho ou ?last_event_id=, tanto faz. O ready volta com missed: as rodadas que fecharam enquanto você estava fora, da mais antiga para a mais nova. O stream resolve ausências de até 50 rodadas; se mais que isso fecharam, ele não devolve as mais recentes e nem tenta — missed vem null com too_many_missed, e você fecha o buraco pelo /results?after=. O data continua sendo a última rodada encerrada, que normalmente é o último item de missed. Quando não dá para recuperar, missed vem null e resyncError diz por quê; a conexão abre de qualquer forma, porque uma reconexão não pode falhar por causa de um cursor velho.

curl -N https://api.lynxmetrics.com/v1/lightning-baccarat/stream \
  -H "x-api-key: SUA_CHAVE" \
  -H "accept: text/event-stream" \
  -H "last-event-id: v1793314712000"
  • bad_cursorresyncError

    O valor enviado não é um id de rodada nem uma data ISO 8601.

  • unknown_roundresyncError

    Esse id não é de nenhuma rodada nossa nesta API. Pode ser de outra API, ou de uma rodada que acabou descartada: um phase não garante que a rodada vai existir.

  • plan_limitresyncError

    A rodada é mais antiga que o histórico do seu plano.

  • too_many_missedresyncError

    Mais de 50 rodadas fecharam na sua ausência, ou seja, você ficou fora tempo demais para o stream resolver sozinho. Peça /results?after= com o id que você tem e pagine até ficar em dia.

Como manter a conexão

  • Dentro de uma conexão os eventos saem um por vez e em ordem cronológica: as fases de uma rodada sempre antes do resultado dela — betting, resolving e round, com o mesmo ref —, e cada round com settledAt maior que o do anterior. O betting de uma rodada pode chegar pouco antes do round da anterior, porque um vem da mesa e o outro do banco; o que vale é a ordem dentro de cada rodada. Nenhuma rodada chega duas vezes na mesma conexão. Se a sua conexão ficar lenta e a fila dela estourar, as rodadas mais antigas são descartadas e vai um event: gap avisando.
  • Cada plano tem um número de conexões simultâneas por chave, na tabela de limites abaixo. Passar desse número não dá erro: a conexão mais antiga daquela chave é encerrada com um event: closed e a nova entra no lugar. Assim um processo que caiu sem o sistema avisar nunca tranca você para fora da sua própria vaga.
  • Toda conexão é encerrada depois de 6 horas, mesmo saudável, e cabe ao cliente reconectar. Esse fim não manda evento nenhum: a conexão simplesmente fecha, e o closed é só da substituição, então uma leitura que termina sem motivo depois de horas abertas é este prazo. É de propósito: conexão que morre sem avisar existe, e esse prazo é o que impede que ela ocupe lugar para sempre. Quem roda o dia inteiro reconecta cerca de quatro vezes por dia.
  • Se o seu cliente tem tempo limite de leitura, deixe-o acima de 20 segundos, senão ele corta a conexão no silêncio entre uma rodada e outra.
  • Abrir a conexão gasta uma requisição do seu limite por minuto. As rodadas que chegam depois não gastam nada, então acompanhar pelo stream pesa menos no limite do que ficar consultando o /latest.
  • A chave só é aceita no cabeçalho x-api-key, nunca na URL, que ficaria em log de proxy e em histórico. Por isso o EventSource do navegador não serve: ele não envia cabeçalhos. No navegador, o caminho é um fetch lendo o corpo aos poucos; melhor ainda é o seu servidor ouvir o stream e repassar, porque uma chave no navegador ficaria à vista de qualquer visitante.

GET /v1/lightning-baccarat/stats

Estatísticas do Lightning Baccarat calculadas na hora sobre as últimas rodadas.

  • samplenumber

    Sobre quantas rodadas recentes calcular, com padrão 100 e máximo 250 a 1000.

GET /v1/lightning-baccarat/stats

{
  "data": {
    "total": 100,
    "counts": { "player": 44, "banker": 47, "tie": 9 },
    "percentages": { "player": 44, "banker": 47, "tie": 9 },
    "currentStreak": { "outcome": "banker", "length": 2 },
    "outcomes": {
      "player": {
        "count": 44,
        "percent": 44,
        "longestStreak": 4,
        "sinceLast": 2
      },
      "banker": {
        "count": 47,
        "percent": 47,
        "longestStreak": 7,
        "sinceLast": 0
      },
      "tie": {
        "count": 9,
        "percent": 9,
        "longestStreak": 1,
        "sinceLast": 6
      }
    },
    "sample": {
      "from": "2026-11-14T14:20:31.204Z",
      "to": "2026-11-14T15:18:27.939Z"
    },
    "pairs": { "player": 7, "banker": 8 },
    "naturals": 31
  }
}

Campos de cada rodada

Formato de cada rodada do Lightning Baccarat em latest e results.

  • idstring

    Id da rodada, único e estável. É gerado por nós, não pelo provedor, então use-o só para comparar e como cursor (em after e last-event-id), sem interpretar o conteúdo.

  • gamestring

    Slug da API, que aqui é sempre "lightning-baccarat".

  • tableIdstring | null

    Id da mesa no provedor, ou null quando a fonte não informa.

  • startedAtstring | null

    Início da rodada em UTC, ou null quando a fonte não informa.

  • settledAtstring

    Fim da rodada em UTC, que é a data usada na ordenação e em before.

  • outcome"player" | "banker" | "tie"

    Quem ganhou a rodada: player, banker ou tie, que é o empate.

  • data.player.cardsstring[]

    Cartas do Player na ordem em que saíram, duas ou três, cada uma como KH: valor em A23456789TJQK (T é o dez) e naipe em CDHS.

  • data.player.scorenumber

    Pontuação do Player, de 0 a 9: a soma das cartas no módulo 10.

  • data.player.pairboolean

    true quando as duas primeiras cartas do Player têm o mesmo valor.

  • data.banker.cardsstring[]

    Cartas do Banker na ordem em que saíram, no mesmo formato das do Player.

  • data.banker.scorenumber

    Pontuação do Banker, de 0 a 9.

  • data.banker.pairboolean

    true quando as duas primeiras cartas do Banker têm o mesmo valor.

  • data.naturalboolean

    true quando algum lado fez 8 ou 9 com as duas primeiras cartas, o que encerra a rodada sem terceira carta.

Campos das estatísticas

  • totalnumber

    Quantas rodadas entraram na conta, igual ao sample ou menos se ainda houver poucas.

  • counts{ player, banker, tie }

    Vitórias de Player, de Banker e empates na amostra.

  • percentages{ player, banker, tie }

    As mesmas contagens em porcentagem, com uma casa decimal.

  • currentStreak{ outcome, length } | null

    Resultado que está se repetindo agora e há quantas rodadas, ou null sem rodadas.

  • outcomes{ player, banker, tie }

    Um bloco por resultado: count (quantas vezes saiu), percent, longestStreak (a maior sequência seguida na amostra) e sinceLast (rodadas desde a última vez, com 0 para a rodada mais recente e null se não saiu na amostra). Tem a mesma forma em todas as APIs.

  • sample{ from, to } | null

    Período da amostra: o settledAt da rodada mais antiga (from) e da mais nova (to), ou null sem rodadas.

  • pairs{ player, banker }

    Quantas rodadas da amostra tiveram par no Player e no Banker.

  • naturalsnumber

    Quantas rodadas da amostra terminaram em natural.

Planos e limites

Limites da API do Lightning Baccarat em cada plano. Um parâmetro acima do máximo é reduzido ao máximo, e um before mais antigo que o histórico do plano responde plan_limit. A coluna por minuto é o limite de requisições por minuto de cada assinatura, somando todas as chaves dela, e a coluna de conexões é quantas conexões do /stream a mesma chave pode ter abertas ao mesmo tempo.

PlanoPreçoPor minutoConexõeslimitsamplebefore
Teste2 horas, sem cartão6012502507 dias
ProR$ 21,90/mês6012502507 dias
BusinessR$ 49,90/mês400510001000completo

Os erros têm o mesmo formato em todas as APIs e estão listados na documentação geral.