18+ Only  |  Gambling can be addictive — please gamble responsibly  |  Gambling Help: 1800 858 858  |  GambleAware

Download historical racing odds in Python: closing lines, price paths and CLV

Live prices tell you what the market thinks now. A model needs what the market thought at the jump, and what happened next. PuntersEdge keeps a closing-line archive for that: for every Australian and New Zealand race a customer-served bookmaker priced, each book's first price captured in the hour before the jump, its last price before the jump, and the result where one is published. This tutorial pulls the archive into pandas, answers two questions with it, draws one runner's price path, and scores bets against the close.

Every block below was run against the live API, and the output under each one is what it printed: the backtest filter on 19 October 2026, the rest on 28 September 2026.

18+ only. This is data tooling, not tipping or advice, and nothing below is a staking strategy. Gambling Help: 1800 858 858.

What you need

A paid key. Standard reads the last 90 days of the archive; Plus and above read all of it, and steps 5 and 6 (price paths and closing line value) are Plus and above. Free and Hobby keys get a 403 on the archive and are not charged. See pricing for which plan has what. Set the key as an environment variable and pass it in the X-API-Key header:

import io
import os

import pandas as pd
import requests

API = "https://api.puntersedge.online/v1"
HEADERS = {"X-API-Key": os.environ["PUNTERSEDGE_API_KEY"]}

Step 1: see what the archive holds

/v1/racing/closing-lines/coverage costs 1 credit and describes the whole archive: how far back it goes, how many races and books, and how much of it is a genuine closing line (a last price inside the final five minutes; the rest stopped being quoted early, so their close is a last-seen price).

r = requests.get(f"{API}/racing/closing-lines/coverage", headers=HEADERS, timeout=30)
r.raise_for_status()
cov = r.json()
print(f'{cov["archive_from"][:10]} to {cov["archive_to"][:10]}: {cov["races"]:,} races, '
      f'{cov["rows"]:,} rows, {cov["bookmakers"]} bookmakers')
print(f'{cov["is_closing_line_pct"]}% of rows are a genuine closing line')
2026-08-04 to 2026-09-28: 40,289 races, 1,447,227 rows, 14 bookmakers
84.17% of rows are a genuine closing line

Step 2: a day of closing lines into pandas

/v1/racing/closing-lines returns one row per race, runner and bookmaker: open_win_price, close_win_price, is_closing_line, open_is_baseline, finish_position, result_status, the venue and race, and runner_key and runner_ref to join on. A JSON page holds at most 5,000 rows and costs 5 credits, so page through:

def closing_lines(**params):
    """Every row for a query. JSON pages hold at most 5,000 rows, so page through."""
    rows, offset = [], 0
    while True:
        r = requests.get(f"{API}/racing/closing-lines", headers=HEADERS, timeout=120,
                         params={**params, "limit": 5000, "offset": offset})
        r.raise_for_status()
        page = r.json()
        rows += page["rows"]
        offset += page["rows_returned"]
        if page["rows_returned"] == 0 or offset >= page["total_rows"]:
            return pd.DataFrame(rows)

df = closing_lines(date="2026-09-26", country="AU", categories="horse",
                   resulted_only="true")
print(f"{len(df):,} rows: {df.race_id.nunique()} races, "
      f"{df.runner_key.nunique()} runners, {df.bookmaker_key.nunique()} bookmakers")
7,630 rows: 80 races, 784 runners, 12 bookmakers

For bulk pulls, format=csv returns up to 50,000 rows in one request for 20 credits, with the same columns:

r = requests.get(f"{API}/racing/closing-lines", headers=HEADERS, timeout=120, params={
    "date": "2026-09-26", "country": "AU", "categories": "horse",
    "resulted_only": "true", "format": "csv", "limit": 50000})
r.raise_for_status()
df_csv = pd.read_csv(io.StringIO(r.text))
print(f"{len(df_csv):,} rows, {len(df_csv.columns)} columns")
7,630 rows, 29 columns

Before you model: the backtest filter, and what it leaves out

By default /v1/racing/closing-lines already returns only genuine closing lines and hides scratched runners and flagged rows. To see what that removes — and to apply the same filter to a bulk file, which keeps those rows with their flags — ask for everything and filter it yourself. The recommended filter for modelling keeps a row when it is a genuine closing line, the runner was not scratched, and none of the archive's own flags is set; add a final result if you are settling:

everything = closing_lines(date="2026-10-17", country="AU", categories="horse",
                           resulted_only="true", closing_only="false",
                           include_flagged="true", include_scratched="true")
flag = lambda col: (everything[col].fillna(False).astype(bool) if col in everything
                    else pd.Series(False, index=everything.index))
excluded = pd.DataFrame({
    "not a closing line (last-seen price)": ~everything.is_closing_line,
    "runner scratched": flag("scratched"),
    "possible split meeting": flag("venue_split_suspect"),
    "runner-name fragment": flag("name_fragment_suspect"),
    "duplicate race record": flag("duplicate_suspect"),
    "result not final": ~everything.result_status.eq("final"),
})
print(f"{len(everything):,} rows before the filter; rows excluded for each reason:")
print(excluded.sum().to_string())
clean = everything[~excluded.any(axis=1)]
print(f"{len(clean):,} rows kept ({len(clean) / len(everything):.1%}), "
      f"{clean.race_id.nunique()} races")
18,425 rows before the filter; rows excluded for each reason:
not a closing line (last-seen price)    408
runner scratched                         90
possible split meeting                    0
runner-name fragment                      0
duplicate race record                     0
result not final                          0
17,927 rows kept (97.3%), 129 races

A row can fail more than one test, so the reasons can add up to more than the rows removed. Print this table for every window you model on: a day with many last-seen prices or flagged rows is a day to read more carefully, and the data quality page shows the same counts for the whole archive. An absent flag column means the row was not assessed, which the flag helper treats as not flagged.

Step 3: how often did the favourite win?

Take each runner's best closing price across the books, call the shortest runner in each race the favourite, and check it against the result. Two details matter. Group on runner_key, not runner_name: books spell names differently, so one horse can appear as UPTOWN MONK and Uptown Monk. And results publish placegetters only, so an unplaced runner has no finish_position; in a final result that means it did not win, which is what eq(1) gives you.

closes = df[df.is_closing_line & df.result_status.eq("final")]
best = (closes.groupby(["race_id", "runner_key"], as_index=False)
              .agg(venue=("venue", "first"), race_number=("race_number", "first"),
                   runner_name=("runner_name", "first"),
                   finish_position=("finish_position", "max"),
                   close=("close_win_price", "max")))
fav = best.loc[best.groupby("race_id")["close"].idxmin()]
won = fav.finish_position.eq(1)
print(f"The favourite won {won.sum()} of {len(fav)} races ({won.mean():.0%}), "
      f"median price ${fav.close.median():.2f}")
print(f"$1 on every favourite at the best closing price: "
      f"{(fav.close * won).sum() - len(fav):+.2f} units")
The favourite won 32 of 80 races (40%), median price $2.90
$1 on every favourite at the best closing price: +2.95 units

One day is 80 races, which is noise, and the best closing price across 12 books is not a price anyone reliably gets at the jump. The point is the method: the same code over 90 days (Standard) or the whole archive (Plus) gives you a real baseline to measure a model against.

Step 4: did late market moves beat their price?

Here open_win_price is the first price captured in the final hour, and open_is_baseline marks the series that start at the beginning of that hour, so keep only those. Bucket each runner by how its price moved in the last hour, then compare the wins each bucket actually had with the wins its closing prices implied (the sum of 1/price):

week = closing_lines(**{"from": "2026-09-20", "to": "2026-09-27"},
                     country="AU", categories="horse", resulted_only="true")
w = week[week.is_closing_line & week.open_is_baseline & week.result_status.eq("final")].copy()
w["move"] = w.close_win_price / w.open_win_price - 1
runners = (w.groupby(["race_id", "runner_key"], as_index=False)
             .agg(move=("move", "median"),
                  won=("finish_position", lambda s: s.eq(1).any()),
                  close=("close_win_price", "median")))
runners["bucket"] = pd.cut(runners.move, [-1, -0.2, -0.05, 0.05, 0.2, 99],
                           labels=["shortened 20%+", "shortened 5-20%", "steady",
                                   "drifted 5-20%", "drifted 20%+"])
table = runners.groupby("bucket", observed=True).agg(
    runners=("won", "size"), wins=("won", "sum"),
    implied_wins=("close", lambda p: (1 / p).sum()))
table["wins / implied"] = table.wins / table.implied_wins
print(f"{runners.race_id.nunique()} races, {len(runners):,} runners")
print(table.round(2).to_string())
345 races, 3,336 runners
                 runners  wins  implied_wins  wins / implied
bucket                                                      
shortened 20%+       296    23         33.88            0.68
shortened 5-20%      658    74        111.12            0.67
steady               568    91         96.53            0.94
drifted 5-20%        736    95        102.38            0.93
drifted 20%+        1078    61         71.83            0.85

Every bucket sits below 1.0 because a bookmaker's prices carry a margin. What a model looks for is the relative gap: in this week, runners that shortened in the last hour won about two-thirds of what their closing price implied, while steady and drifting runners came closer to their price. It is one week and 345 races, so run it over the full window before believing any of it.

Step 5: one runner's price path

/v1/racing/price-paths returns every captured price point, per runner and book, from the start of the window to the last pre-jump quote (5 credits, Plus and above; on Standard, /v1/racing/price-history answers the same question for one race). Here is the first favourite from step 3, book by book:

race = fav.iloc[0]
r = requests.get(f"{API}/racing/price-paths", headers=HEADERS, timeout=60,
                 params={"race_id": race.race_id, "limit": 5000})
r.raise_for_status()
path = pd.DataFrame(r.json()["rows"])
mine = path[path.runner_key == race.runner_key].sort_values("captured_at")
print(f"{race.venue} R{race.race_number}, {race.runner_name}: "
      f"{len(mine)} price points from {mine.bookmaker_key.nunique()} books")
print(mine.groupby("bookmaker_key")["win_price"].agg(["first", "last", "count"]).head(4).to_string())
Murray Bridge R4, Uptown Monk: 126 price points from 13 books
               first  last  count
bookmaker_key                    
betgold          3.6   3.1     12
betr_au          3.7   3.1      7
betright         3.7   3.2     10
boostbet         3.6   3.1     12

Step 6: score your own bets against the close

POST /v1/racing/clv takes up to 200 bets per request for 5 credits (Plus and above). Name each race by race_id, or by venue, meeting date and race number, and the runner by runner_ref, saddlecloth or name. Each bet comes back with the closing price it is measured against (the best close by default, "reference": "median" for the median, or the named bookmaker's own close if you send one), its closing line value, whether it beat the close, and once the result is final, whether it won and its profit or loss:

bets = [
    {"ref": "bet-1", "race_id": fav.iloc[0].race_id, "runner_name": fav.iloc[0].runner_name,
     "price": 3.75, "stake": 10},
    {"ref": "bet-2", "race_id": fav.iloc[1].race_id, "runner_name": fav.iloc[1].runner_name,
     "price": 3.10, "stake": 10},
]
r = requests.post(f"{API}/racing/clv", headers=HEADERS, timeout=60, json={"bets": bets})
r.raise_for_status()
res = r.json()
for b in res["bets"]:
    print(f'{b["ref"]}: took {b["price_taken"]}, closed {b["close_reference"]}, '
          f'CLV {b["clv_pct"]:+.1f}%, won {b["won"]}, P&L {b["pnl"]:+.2f}')
s = res["summary"]
print(f'average CLV {s["avg_clv_pct"]:+.2f}%, beat the close {s["beat_close"]} of {s["scored"]}')
bet-1: took 3.75, closed 3.4, CLV +10.3%, won False, P&L -10.00
bet-2: took 3.1, closed 3.3, CLV -6.1%, won False, P&L -10.00
average CLV +2.11%, beat the close 1 of 2

Beating the close is the signal a model is finding value before the market does; winning or losing one bet is not. Across hundreds of bets, the average closing line value is the number to watch.

To log tips as you take them and settle them after the race on a Standard key, without the CLV endpoint, the tip tracker example on GitHub does it in one script: it records the best price on offer, then reads the closing price and the finish from /v1/racing/closing-lines.

Things that will bite you

API reference for the endpoints in this guide

Get an API key →

This site contains wagering-related analysis and is intended for Australian users aged 18+. Gambling involves risk. Please gamble responsibly.