Blog · Baccarat 1

Baccarat 1 history: how to download the previous hands

How to pull the full Baccarat 1 history through the API: paging with before, syncing with after, exporting to CSV and what the data lets you study.

Published on November 2, 2026 · 6 min read

Any stream shows you the last result for free. What you cannot find lying around is the complete, gap-free Baccarat 1 history: every hand, in order, with the cards that came out. That is where a results API earns its place, and it is what this article teaches you to download.

The Baccarat 1 API keeps every hand read since 1 November 2026, the day it went live. Nothing is discarded: the Pro plan queries the last 7 days and Business everything.

It helps to know the volume before you start. The table deals a hand every 30 seconds at the median, with pauses of minutes to shuffle and change dealer:

WindowHands, in order of magnitude
1 houraround 100
1 daya few thousand
7 days (what Pro covers)tens of thousands

So downloading the whole Pro window is dozens of pages, not three. The script below handles that.

The history endpoint

curl "https://api.lynxmetrics.com/v1/baccarat-1/results?limit=100" \
  -H "x-api-key: YOUR_KEY"

The response returns hands newest first, in the same format as /latest, plus a cursor:

{
  "data": [ { "id": "v1793553361643", "settledAt": "2026-11-01T17:16:21.643Z", "outcome": "player", "...": "..." } ],
  "nextCursor": "2026-11-01T17:15:48.201Z"
}
ParameterWhat it does
limitHow many hands to return. Default 50, maximum 250 on Pro and 1,000 on Business
beforeOnly hands settled before this timestamp. This is where the previous page's nextCursor goes
afterOnly hands settled after the id or settledAt you pass, oldest first

When nextCursor comes back null, there are no more pages.

Downloading the whole history, one page at a time

The pattern is always the same: ask for a page, store it, send the cursor back in before, repeat. In Python:

download-history.py

import json
import time
import requests

URL = "https://api.lynxmetrics.com/v1/baccarat-1/results"
HEADERS = {"x-api-key": "YOUR_KEY"}

hands = []
cursor = None
while True:
    params = {"limit": 250}
    if cursor:
        params["before"] = cursor
    response = requests.get(URL, headers=HEADERS, params=params, timeout=30)
    response.raise_for_status()
    body = response.json()
    hands.extend(body["data"])
    cursor = body["nextCursor"]
    print(len(hands), "hands")
    if not cursor:
        break
    time.sleep(1)   # slack for the per-minute limit

with open("baccarat-1.json", "w", encoding="utf-8") as file:
    json.dump(hands, file, ensure_ascii=False)

Three things worth noticing here:

  • The time.sleep(1). The limit is per minute (60 requests on Pro, 400 on Business), and a one-second pause between pages keeps you well clear of it. Without a pause you get 429 with a Retry-After header telling you how long to wait — the codes are all in API errors and limits.
  • A before older than your plan's history answers plan_limit. On Pro that happens when you reach the 7 days: it is not a bug in your code, it is the end of what the plan covers.
  • With limit=250 and a one-second pause, an hour of table comes down in well under a second of work and a whole day in a few minutes. Parallelising is not worth it: the per-minute limit is the ceiling, not your connection.

Keeping a copy up to date: the after parameter

If you store the hands in a database of your own, after is more useful than before. You pass the id of the last hand you already have and receive only what came after it, in chronological order:

def sync(last_id):
    while True:
        r = requests.get(URL, headers=HEADERS, params={"after": last_id, "limit": 250}, timeout=30)
        body = r.json()
        for hand in body["data"]:
            store(hand)             # your database, keyed on the unique id
            last_id = hand["id"]
        if not body["nextCursor"]:
            return last_id          # you are up to date

That is the right way to never skip or repeat a hand, and it is also the stream's companion. A short drop the stream fixes by itself: reconnecting with last-event-id returns up to 50 missed hands — on this table, about 25 minutes. /results?after= takes over when you were away longer than that, when the stream reported resyncError: "too_many_missed", or when you are building the copy for the first time. The live path is in Baccarat 1 results live, and the storage design in storing real-time data.

Turning it into CSV or a spreadsheet

For studying in Excel, Sheets or pandas, nested JSON gets in the way. One row per hand fixes it:

to-csv.py

import csv

with open("baccarat-1.csv", "w", newline="", encoding="utf-8") as file:
    writer = csv.writer(file)
    writer.writerow(
        ["id", "settledAt", "outcome", "player_cards", "player_score", "player_pair",
         "banker_cards", "banker_score", "banker_pair", "natural", "cards"]
    )
    for h in hands:
        p, b = h["data"]["player"], h["data"]["banker"]
        writer.writerow([
            h["id"], h["settledAt"], h["outcome"],
            " ".join(p["cards"]), p["score"], p["pair"],
            " ".join(b["cards"]), b["score"], b["pair"],
            h["data"]["natural"], len(p["cards"]) + len(b["cards"]),
        ])

The last column, the total number of cards in the hand, does not come from the API: it is a one-line calculation that separates the short hands from the ones that went to a third card on the spot. That kind of derived column is where the history starts paying off.

What the history lets you study

With the hands in hand, questions nobody can answer by watching the stream are one query away:

  • How many hands an hour the table really deals, and when it stops to shuffle or change dealer.
  • What fraction of hands ends in a natural, and how that compares with the theoretical probability.
  • How often a pair shows up on each side, which is the most common side bet.
  • The distribution of streak lengths: how many times the same side won 3, 4, 5 times in a row in your sample.
  • How far your sample drifts from the long-run percentages, which is the exercise in Baccarat 1 statistics.

It is worth saying what the history does not do, because it is the most tempting use and the only one that does not work: it does not point to the next hand. Testing a strategy against the past shows how it would have behaved in that past, and nothing beyond that — every new hand comes out of a shuffled shoe, indifferent to what came before.

How much history each plan covers

PlanPriceHistoryPer requestPer minute
ProR$ 21.90/monthlast 7 daysup to 250 hands60 requests
BusinessR$ 49.90/monthfull, since 1 Nov 2026up to 1,000 hands400 requests

The free 2-hour trial uses Pro limits, so you can run the whole download script before subscribing to anything. Every field is listed in the documentation and explained in the API overview.

Frequently asked questions

How far back does the Baccarat 1 history go on LynxMetrics?

To 1 November 2026, when the API went live. Every hand read since then is kept, with nothing discarded: the Pro plan queries the last 7 days and Business the full history.

How many Baccarat 1 hands come in each request?

The default is 50 and the maximum is 250 on the Pro plan and 1,000 on Business. To go further, pass the response's nextCursor in the before parameter and ask for the next page.

How do I sync my database without repeating or skipping hands?

Use the after parameter with the id of the last hand you already have: the response returns only the hands settled after it, oldest first. Store the id as a unique key, because it is fixed and never changes.

Can I export the Baccarat 1 history to CSV or Excel?

Yes. The API returns JSON and a dozen lines of Python convert it to CSV, with one row per hand and columns for cards, score, pair and natural. The article includes the ready-made script.

Can the history predict the next hand?

No. It shows what happened and lets you measure past frequencies and streaks. Every new hand comes out of a shuffled shoe and does not depend on the previous ones, so no pattern in the history points to the next result.

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