Blog · Baccarat 1

Baccarat 1 results live: every hand in about 3 seconds

How to receive every hand from Pragmatic Play's Baccarat 1 the moment it closes, with the LynxMetrics stream: the delay measured in production and the code.

Published on November 2, 2026 · 8 min read

Ver os resultados da Baccarat 1 via API: histórico, estatísticas e stream · on YouTube

Receiving Baccarat 1 results live is a different problem from querying history. In history, delay does not matter. Live, it matters entirely: the table deals a hand every 30 seconds, so if your message goes out 20 seconds after the hand, it lands almost together with the next one, and whoever reads it no longer knows which round you mean.

This article covers the two paths the Baccarat 1 API offers for following the table live, which one is fastest, and how much time really passes between the hand closing and the data reaching your program. How the stream works in detail — every event, the timestamps and the recovery errors — is in the reference article on real-time results; the numbers for this table are here.

The real delay, measured in production

The right yardstick is not "the API is fast", it is how many seconds pass between the hand ending and the data being available. On Baccarat 1 we measured that across the rounds in our database, comparing each hand's settledAt with the moment it was stored: the median was 3.0 seconds, over 268 checked hands.

What we measuredValue
Median from the hand ending to the data stored3.0 s
Median gap between hands30 s
Shortest gap observed26 s
When the table shuffles or changes dealera pause of minutes

Almost all of that time is confirming the hand, before the round exists for us at all; our database accounts for a fraction of it. So there is no client-side trick that wins those seconds back, and no reason to poll the API ten times a second: the data simply is not there any earlier.

And you do not have to take our word for it: every hand that arrives on the stream carries the timestamps for each leg of the trip, so the number above is verifiable on your side, with your own clock.

# inside the "round" event
from datetime import datetime

t = lambda iso: datetime.fromisoformat(iso.replace("Z", "+00:00"))
table_to_us = (t(event["timing"]["receivedAt"]) - t(event["data"]["settledAt"])).total_seconds()
print(round(table_to_us, 2), "s from the table to our API")

With a 3-second delay on a 30-second hand, you have about 27 seconds until the next one — plenty of slack to format and publish.

Path 1: the stream, the fastest one

GET /v1/baccarat-1/stream is an HTTP connection that stays open. You open it once and the API pushes every hand the moment it is stored, as Server-Sent Events. There is no polling interval, so there is no polling delay.

In Python, with httpx:

stream.py

import json
import httpx

URL = "https://api.lynxmetrics.com/v1/baccarat-1/stream"
HEADERS = {"x-api-key": "YOUR_KEY", "accept": "text/event-stream"}

with httpx.stream("GET", URL, headers=HEADERS, timeout=None) as response:
    response.raise_for_status()
    event = None
    for line in response.iter_lines():
        if line.startswith("event:"):
            event = line.split(":", 1)[1].strip()
        elif line.startswith("data:") and event == "round":
            body = json.loads(line.split(":", 1)[1])
            hand = body["data"]
            print(hand["outcome"], hand["data"]["player"]["cards"], hand["data"]["banker"]["cards"])

In Node.js 18 or newer, with no dependency:

stream.mjs

const response = await fetch("https://api.lynxmetrics.com/v1/baccarat-1/stream", {
  headers: { "x-api-key": process.env.LYNX_KEY, accept: "text/event-stream" },
});

let buffer = "";
for await (const chunk of response.body) {
  buffer += new TextDecoder().decode(chunk);
  const blocks = buffer.split("\n\n");
  buffer = blocks.pop() ?? "";
  for (const block of blocks) {
    const event = block.match(/^event: (.+)$/m)?.[1];
    const data = block.match(/^data: (.+)$/m)?.[1];
    if (event === "round" && data) {
      const { data: hand } = JSON.parse(data);
      console.log(hand.outcome, hand.data.player.score, hand.data.banker.score);
    }
  }
}

What arrives on the connection

EventWhen it arrivesWhat to do with it
readyOnce, on openingCarries the last hand already settled, so you start up to date, and on a reconnect carries in missed whatever closed while you were away. It is not a new hand
roundOne per new handThe round in data and the delivery timestamps in timing. It is the only event with an id:
closedAnother connection opened with the same keyEnd of life for this process; reconnecting would drop the new connection
a line with :Every 20 seconds of silenceA heartbeat, so no proxy closes an idle connection. Ignore it

On this table the connection receives those three events. The phase event that Lightning Baccarat sends when the table starts resolving a hand is not published for Baccarat 1 — and you do not need it to know which hand a result belongs to: the round's id, the guaranteed order and last-event-id are enough.

Reconnecting without missing a hand

An open connection will drop — network, deploys, and the end of life every connection has. Keep the id of the last hand you handled and send it back in the last-event-id header when you reopen: ready comes back with missed, the hands that closed while you were away, oldest first, up to 50.

headers = {"x-api-key": "YOUR_KEY", "accept": "text/event-stream"}
if last_id:
    headers["last-event-id"] = last_id

Beyond 50 missed hands — on this table, about 25 minutes — the stream cannot fix it alone: resyncError: "too_many_missed" arrives and you finish syncing with `/results?after=`, which pages. The connection opens either way; a reconnect never fails because of a stale cursor.

When the table simply stops

Shuffling and dealer changes stop the table for minutes, and no round arrives during those gaps. That is not an outage: the heartbeat keeps coming and the connection stays alive. If your program draws a "live" badge on screen, use the last hand's settledAt to say how long ago it came out, rather than assuming a long pause is an error.

A hand whose reading is not certain is dropped on purpose — better a missing hand than a wrong one — so your program should never assume hands arrive at exact intervals.

What the stream costs you in limits

Opening the connection spends one request from your per-minute limit. The hands that arrive afterwards cost nothing. Following the table on the stream therefore weighs far less on your limit than polling /latest every 3 seconds, which is 20 requests a minute. The Pro plan holds 1 connection per key, Business 5.

If you go over your plan's connection count there is no error: the oldest connection on that key is closed with an event: closed and the new one takes its place. That way a process that died without warning never locks you out of your own slot.

Path 2: polling /latest

If your program cannot hold a connection open — a serverless function, a cron job, a spreadsheet — polling /latest works well. Two rules make it efficient:

  • Every 3 seconds is plenty. The hand takes 30 seconds and the data arrives in 3; polling faster than that only burns your per-minute limit.
  • Send the ETag. Keep the ETag header from the previous response and return it in If-None-Match. When nothing has changed the API answers 304 with no body: the request still counts against the limit, but the traffic and the work on your side drop a lot.
etag = None
while True:
    headers = {"x-api-key": "YOUR_KEY"}
    if etag:
        headers["if-none-match"] = etag
    r = requests.get("https://api.lynxmetrics.com/v1/baccarat-1/latest", headers=headers, timeout=10)
    if r.status_code == 200:
        etag = r.headers.get("etag")
        handle(r.json()["data"])
    time.sleep(3)

And always compare the hand's id with the last one you handled. That is how you never publish the same round twice, and it applies to both paths.

Stream, polling or webhook: which to choose

Stream (SSE)Polling /latestWebhook
Extra delay beyond the ~3snonehalf your interval, on average—
Per-minute limit cost1 on opening1 per poll—
Recovers what you missed in a dropyes, with last-event-idyes, with after—
Needs a server of your ownyes, a running processnoyes, a public URL
Available on LynxMetricsyesyesno

Webhooks are the question we get most, and the answer is straightforward: there is none today. A webhook requires a public URL, request signing and a redelivery queue on our side, and it delivers worse than the stream for anyone who already has a process running.

The next step

With the stream working, what is left is deciding what to do with each hand: post it to a group, store it in your own database (the path is in storing real-time data) or draw it on screen. To understand every field that arrives in the event, see the Baccarat 1 API and the documentation. If you only want to watch the table, there is the live Baccarat 1 page, open and keyless.

Frequently asked questions

What is the delay between a Baccarat 1 hand and the data in the API?

The median measured in production is 3 seconds between the hand ending and the data being stored, over 268 checked hands. Almost all of that time is confirming the hand, and every round on the stream carries timestamps so you can measure it on your side.

Does LynxMetrics have a webhook for Baccarat 1?

No. To receive every hand the moment it is stored, use the /stream endpoint, which holds an HTTP connection open (Server-Sent Events). It covers the same use case with fewer moving parts than a webhook.

How do I reconnect to the Baccarat 1 stream without missing hands?

Send the id of the last hand you received in the last-event-id header when reopening the connection. The ready event comes back with missed, the hands that closed while you were away, up to 50. Beyond that you get resyncError too_many_missed and finish syncing through /results?after=.

How many stream connections can I keep open?

One per key on the Pro plan and five on Business. If you open more than that with the same key, the oldest connection is closed with an event: closed and the new one takes its place, with no error.

Why does Baccarat 1 go minutes without sending any hand?

Because the table paused to shuffle or change dealer, which takes minutes. The connection stays alive and the heartbeat keeps arriving; use the last hand's settledAt to show how long ago it came out instead of treating the pause as an error.

For adults 18 and over only. LynxMetrics is not affiliated with Pragmatic Play or with the casinos that offer Baccarat 1, and it only sells data and stats, never predictions or betting tips, because every round is random and past results do not predict the next one.

Read also