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:
| Window | Hands, in order of magnitude |
|---|---|
| 1 hour | around 100 |
| 1 day | a 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"
}| Parameter | What it does |
|---|---|
limit | How many hands to return. Default 50, maximum 250 on Pro and 1,000 on Business |
before | Only hands settled before this timestamp. This is where the previous page's nextCursor goes |
after | Only 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 get429with aRetry-Afterheader telling you how long to wait — the codes are all in API errors and limits. - A
beforeolder than your plan's history answersplan_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=250and 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 dateThat 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
| Plan | Price | History | Per request | Per minute |
|---|---|---|---|---|
| Pro | R$ 21.90/month | last 7 days | up to 250 hands | 60 requests |
| Business | R$ 49.90/month | full, since 1 Nov 2026 | up to 1,000 hands | 400 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
- Baccarat 1 API (Pragmatic Play): live results in JSON
How LynxMetrics' Baccarat 1 API works: every hand from Pragmatic Play's table in JSON, the four endpoints, Python and Node examples, pricing and a free trial.
- Baccarat 1 statistics: Player, Banker, Tie and pairs
How to read Baccarat 1 statistics from Pragmatic Play's table: what the /stats endpoint computes, baccarat's long-run percentages and how a short sample misleads.
- 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.