# Racing Post Racecards Scraper (`parseforge/racing-post-racecards-scraper`) Actor

Scrape Racing Post racecards: one row per runner with silks, horse, jockey, trainer, form, ratings, going and forecast odds. Export to CSV, Excel, JSON or XML.

- **URL**: https://apify.com/parseforge/racing-post-racecards-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Sports, Developer tools, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $6.34 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🏇 Racing Post Racecards Scraper

> 🚀 **Export every runner on today's racecards in seconds.** One row per horse, 58 columns: silks image, course, off time, race name, class, distance, going, prize money, then the horse with its number, draw, age, weight, jockey, trainer, owner, form figures, Official Rating, RPR, Topspeed and the Racing Post betting forecast price. A typical British and Irish day carries **6 to 9 meetings, 37 to 56 races and 370 to 940 runners**, and the whole card is collected over plain HTTP on 1 GB of memory.

Racing Post is the reference publication for British and Irish horse racing. Its racecards are the version of the card that the industry actually reads: the declared field, the weights, the draw, the six most recent form figures, the Official Rating, the Racing Post Rating, the Topspeed figure and the paper's own betting forecast. This Actor reads the same JSON the racingpost.com page renders for an anonymous visitor, so the numbers match the page, and nothing is inferred from screen scraping a table.

Coverage follows the racing calendar. Cards are published for today and the days ahead, the field is declared about 48 hours before the off, and international meetings appear alongside the domestic ones: at verification time the index carried meetings in Great Britain, Ireland, France, the United States, Australia, Hong Kong and Peru.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Form analysts and racing modellers | Build a daily runner table with ratings, form figures and forecast prices |
| Tipping sites and racing media | Publish full cards with silks, jockeys, trainers and going without manual entry |
| Betting and trading desks | Feed a pricing model the declared field, weights, draw and going every morning |
| Bloodstock and syndicate managers | Track your horses, sires and trainers across every card in Britain and Ireland |

### 📋 What the Racing Post Racecards Scraper does

> 💡 **Why it matters:** a British and Irish race day spreads 400 to 900 runners across six to nine meetings and dozens of separate pages, and the card changes as horses are withdrawn. Rebuilding that into a spreadsheet by hand is a morning's work every morning. This Actor returns it as one flat table in a single run, and never bills for a row it did not deliver.

- 🗓️ **A whole day in one input:** leave the defaults and you get every runner declared for today. Set `raceDate` to `tomorrow` or a `YYYY-MM-DD` date for any future card.
- 🔗 **Any racecard URL:** a day index (`/racecards/2026-09-10/`), a meeting (`/racecards/15/doncaster/2026-09-10/`) or a single race (`/racecards/15/doncaster/2026-09-10/926640`). A race URL returns only that race.
- 🏟️ **The race, carried on every row:** course, country, off time in ISO 8601, race name, class, age restriction, rating band, distance in furlongs and in yards, going, going detail with GoingStick and rail movements, surface, weather, winner prize, total prize money, declared runner count and the TV channel.
- 🐎 **The runner:** saddlecloth number, draw, age, weight in stones and pounds and in pounds, jockey with claim, trainer, owner, and links to each of their Racing Post profiles.
- 📈 **The form that analysts use:** the recent form figure string, the Official Rating for the day, the Racing Post Rating, the Topspeed figure, days since last run, headgear with a first-time flag and trainer recent form percentage.
- 🎯 **Betting forecast:** the Racing Post forecast price as the printed fraction (`5/2`) and as a decimal multiplier, ready for a model.
- 🧬 **Breeding:** colour and sex, country of origin, sire, dam and damsire.
- 🎽 **Silks:** the runner's silks image URL, first column, so a card renders straight out of the dataset.
- 🔁 **Clean data:** one runner per row, de-duplicated across sources, the same 58 columns on every row, `Not Disclosed` or `N/A` instead of blank cells, and non-runners excluded unless you ask for them.

### 🎬 Full Demo (🚧 Coming soon)

A short walkthrough video is in production.

### 📊 Output

Each row is one declared runner in one race. Fields, in dataset order:

| Field | Description |
|---|---|
| `imageUrl` | Jockey silks image for this runner (SVG on rp-assets.com) |
| `horseName` | Horse name as printed on the card |
| `horseUrl` | Racing Post horse profile and form page |
| `raceUrl` | Racing Post racecard page for this race |
| `raceId` | Racing Post race identifier |
| `course` | Course name, for example `Doncaster` |
| `countryCode` | Country code of the meeting, for example `GB`, `IRE`, `FR` |
| `country` | Country name |
| `raceDateTime` | Scheduled off time, ISO 8601 UTC |
| `raceDate` | Race date, `YYYY-MM-DD` |
| `raceTimeLocal` | Off time in the meeting's local clock, for example `13:15` |
| `raceName` | Full race title including sponsor |
| `raceClass` | Race class, `N/A` outside Britain where classes are not used |
| `raceType` | `Flat`, `Hurdle`, `Chase` or `NH Flat` |
| `ageRestriction` | Ages allowed, for example `2yo`, `4yo+` |
| `ratingBand` | Official rating band for handicaps, for example `0-100` |
| `distance` | Race distance as printed, for example `6½f`, `2m7f` |
| `distanceYards` | Race distance in yards |
| `going` | Going description, for example `Good To Soft` |
| `goingDetails` | Full going statement with GoingStick and rail movements |
| `surface` | `Turf`, `Polytrack`, `Tapeta`, `Beach` or `All-Weather` |
| `weather` | Weather reported at the meeting |
| `winnerPrize` | Prize to the winner, formatted with its currency symbol |
| `totalPrizeMoney` | Sum of all advertised places, as a number |
| `currency` | Currency of the prize figures, `GBP` or `EUR` |
| `runnerCount` | Runners declared in this race |
| `liveOn` | Broadcaster showing the race, for example `ITV`, `RTV`, `SKY` |
| `saddleClothNumber` | Saddlecloth number |
| `draw` | Stall number, `N/A` in jumps races |
| `age` | Horse age in years |
| `weight` | Weight carried in stones and pounds, for example `8-11` |
| `weightLbs` | Weight carried in pounds |
| `jockey` | Booked jockey |
| `jockeyUrl` | Racing Post jockey profile |
| `jockeyClaimLbs` | Weight allowance the jockey claims, `0` when none |
| `trainer` | Trainer |
| `trainerUrl` | Racing Post trainer profile |
| `trainerFormPercent` | Trainer runners to form percentage over the last 14 days |
| `owner` | Registered owner |
| `ownerUrl` | Racing Post owner profile |
| `form` | Recent form figure string, most recent run last, for example `3213` |
| `officialRating` | Official Rating carried today |
| `rpr` | Racing Post Rating |
| `topSpeed` | Racing Post Topspeed figure |
| `forecastOdds` | Racing Post betting forecast price as a fraction, for example `5/2` |
| `forecastOddsDecimal` | The same forecast price as a decimal multiplier |
| `headGear` | Headgear codes, for example `t` tongue tie, `v` visor, `b` blinkers |
| `firstTimeHeadGear` | `Yes` when the headgear is worn for the first time |
| `daysSinceLastRun` | Days since the horse last raced |
| `countryOfOrigin` | Country the horse was bred in |
| `colourAndSex` | Colour and sex code, for example `b f`, `gr g` |
| `sire` | Sire |
| `dam` | Dam |
| `damSire` | Damsire |
| `comment` | Racing Post race-reader comment on this runner |
| `isNonRunner` | `Yes` when the horse has been withdrawn |
| `scrapedAt` | When the row was collected, ISO 8601 |
| `error` | `null` on data rows; error rows carry a message and are never charged |

Three real records from a verification run:

```json
[
  {
    "imageUrl": "https://www.rp-assets.com/svg/8/9/5/147598.svg",
    "horseName": "Speed Of Sound",
    "horseUrl": "https://www.racingpost.com/profile/horse/8688617/speed-of-sound/form",
    "raceUrl": "https://www.racingpost.com/racecards/15/doncaster/2026-09-10/926640",
    "raceId": "926640",
    "course": "Doncaster",
    "countryCode": "GB",
    "country": "United Kingdom",
    "raceDateTime": "2026-09-10T12:15:00.000Z",
    "raceDate": "2026-09-10",
    "raceTimeLocal": "13:15",
    "raceName": "British Stallion Studs 'Carrie Red' EBF Fillies' Nursery Handicap",
    "raceClass": "2",
    "raceType": "Flat",
    "ageRestriction": "2yo",
    "ratingBand": "N/A",
    "distance": "6½f",
    "distanceYards": 1431,
    "going": "Good To Soft",
    "goingDetails": "GOOD TO SOFT, Good in places (GoingStick: 6.1) (Rail Movements: 2.25 & 5.20 +19yds and 3.00 +9yds)",
    "surface": "Turf",
    "weather": "Light rain",
    "winnerPrize": "£28,347",
    "totalPrizeMoney": 54104,
    "currency": "GBP",
    "runnerCount": 12,
    "liveOn": "ITV",
    "saddleClothNumber": 4,
    "draw": 5,
    "age": 2,
    "weight": "8-11",
    "weightLbs": 123,
    "jockey": "Saffie Osborne",
    "jockeyUrl": "https://www.racingpost.com/profile/jockey/100350/saffie-osborne/",
    "jockeyClaimLbs": 0,
    "trainer": "Richard Spencer",
    "trainerUrl": "https://www.racingpost.com/profile/trainer/30665/richard-spencer/",
    "trainerFormPercent": 69,
    "owner": "Phil Cunningham",
    "ownerUrl": "https://www.racingpost.com/profile/owner/147598/phil-cunningham/",
    "form": "3213",
    "officialRating": 81,
    "rpr": 95,
    "topSpeed": 91,
    "forecastOdds": "5/2",
    "forecastOddsDecimal": 2.5,
    "headGear": "N/A",
    "firstTimeHeadGear": "No",
    "daysSinceLastRun": 21,
    "countryOfOrigin": "IRE",
    "colourAndSex": "b f",
    "sire": "Sioux Nation",
    "dam": "All Speed",
    "damSire": "Camacho",
    "comment": "Form of Yarmouth win lifted since; good 3rd in York sales race latest (6f, good to soft)",
    "isNonRunner": "No",
    "scrapedAt": "2026-09-09T18:53:43.868Z",
    "error": null
  },
  {
    "imageUrl": "https://www.rp-assets.com/svg/3/5/4/231453.svg",
    "horseName": "Art Of Life",
    "horseUrl": "https://www.racingpost.com/profile/horse/9472243/art-of-life/form",
    "raceUrl": "https://www.racingpost.com/racecards/15/doncaster/2026-09-10/926640",
    "raceId": "926640",
    "course": "Doncaster",
    "countryCode": "GB",
    "country": "United Kingdom",
    "raceDateTime": "2026-09-10T12:15:00.000Z",
    "raceDate": "2026-09-10",
    "raceTimeLocal": "13:15",
    "raceName": "British Stallion Studs 'Carrie Red' EBF Fillies' Nursery Handicap",
    "raceClass": "2",
    "raceType": "Flat",
    "ageRestriction": "2yo",
    "ratingBand": "N/A",
    "distance": "6½f",
    "distanceYards": 1431,
    "going": "Good To Soft",
    "goingDetails": "GOOD TO SOFT, Good in places (GoingStick: 6.1) (Rail Movements: 2.25 & 5.20 +19yds and 3.00 +9yds)",
    "surface": "Turf",
    "weather": "Light rain",
    "winnerPrize": "£28,347",
    "totalPrizeMoney": 54104,
    "currency": "GBP",
    "runnerCount": 12,
    "liveOn": "ITV",
    "saddleClothNumber": 2,
    "draw": 9,
    "age": 2,
    "weight": "8-12",
    "weightLbs": 124,
    "jockey": "Rossa Ryan",
    "jockeyUrl": "https://www.racingpost.com/profile/jockey/95744/rossa-ryan/",
    "jockeyClaimLbs": 0,
    "trainer": "Clive Cox",
    "trainerUrl": "https://www.racingpost.com/profile/trainer/5863/clive-cox/",
    "trainerFormPercent": 38,
    "owner": "Isa Salman Al Khalifa",
    "ownerUrl": "https://www.racingpost.com/profile/owner/231453/isa-salman-al-khalifa/",
    "form": "622",
    "officialRating": 82,
    "rpr": 87,
    "topSpeed": 73,
    "forecastOdds": "4/1",
    "forecastOddsDecimal": 4,
    "headGear": "N/A",
    "firstTimeHeadGear": "No",
    "daysSinceLastRun": 27,
    "countryOfOrigin": "GB",
    "colourAndSex": "b f",
    "sire": "Palace Pier",
    "dam": "Musical Art",
    "damSire": "Dutch Art",
    "comment": "All races on good to firm; pulled hard but kept tabs on winner over 7f latest; improve",
    "isNonRunner": "No",
    "scrapedAt": "2026-09-09T18:53:43.878Z",
    "error": null
  },
  {
    "imageUrl": "https://www.rp-assets.com/svg/b/0/7/267270b.svg",
    "horseName": "Wondervision",
    "horseUrl": "https://www.racingpost.com/profile/horse/8881440/wondervision/form",
    "raceUrl": "https://www.racingpost.com/racecards/15/doncaster/2026-09-10/926640",
    "raceId": "926640",
    "course": "Doncaster",
    "countryCode": "GB",
    "country": "United Kingdom",
    "raceDateTime": "2026-09-10T12:15:00.000Z",
    "raceDate": "2026-09-10",
    "raceTimeLocal": "13:15",
    "raceName": "British Stallion Studs 'Carrie Red' EBF Fillies' Nursery Handicap",
    "raceClass": "2",
    "raceType": "Flat",
    "ageRestriction": "2yo",
    "ratingBand": "N/A",
    "distance": "6½f",
    "distanceYards": 1431,
    "going": "Good To Soft",
    "goingDetails": "GOOD TO SOFT, Good in places (GoingStick: 6.1) (Rail Movements: 2.25 & 5.20 +19yds and 3.00 +9yds)",
    "surface": "Turf",
    "weather": "Light rain",
    "winnerPrize": "£28,347",
    "totalPrizeMoney": 54104,
    "currency": "GBP",
    "runnerCount": 12,
    "liveOn": "ITV",
    "saddleClothNumber": 11,
    "draw": 2,
    "age": 2,
    "weight": "8-2",
    "weightLbs": 114,
    "jockey": "Nicola Currie",
    "jockeyUrl": "https://www.racingpost.com/profile/jockey/92938/nicola-currie/",
    "jockeyClaimLbs": 0,
    "trainer": "Jack Channon",
    "trainerUrl": "https://www.racingpost.com/profile/trainer/40161/jack-channon/",
    "trainerFormPercent": 41,
    "owner": "Bramble Syndicate",
    "ownerUrl": "https://www.racingpost.com/profile/owner/267270/bramble-syndicate/",
    "form": "331",
    "officialRating": 72,
    "rpr": 95,
    "topSpeed": 86,
    "forecastOdds": "11/2",
    "forecastOddsDecimal": 5.5,
    "headGear": "N/A",
    "firstTimeHeadGear": "No",
    "daysSinceLastRun": 24,
    "countryOfOrigin": "IRE",
    "colourAndSex": "b f",
    "sire": "Minzaal",
    "dam": "Wonderworld",
    "damSire": "Sea The Moon",
    "comment": "Overcame some trouble in running to win handicap debut over 6f on AW; can progress",
    "isNonRunner": "No",
    "scrapedAt": "2026-09-09T18:53:43.880Z",
    "error": null
  }
]
```

### ✨ Why choose this Actor

| | What you get |
|---|---|
| **Racing Post's own numbers** | Official Rating, RPR, Topspeed, form figures, weights and the betting forecast come from the JSON the page renders, not from parsing a rendered table. |
| **The grain form analysis needs** | One row per runner, with the race repeated on every row, so a CSV opens straight into a pivot table or a model. |
| **Silks in the first column** | Every row carries the runner's silks image URL, so you can render a card without a second lookup. |
| **The going, in full** | Not just `Good To Soft` but the whole going statement with GoingStick reading and rail movements, which is what actually moves a time. |
| **Fractions and decimals** | The forecast price is given both as the printed fraction and as a decimal multiplier, so no parsing on your side. |
| **58 columns, one shape** | Every row has the same keys in the same order, so CSV imports, joins and Excel filters behave. |
| **No blanks, no nulls** | A value Racing Post withholds is `Not Disclosed`; a value that does not apply, such as a draw in a chase, is `N/A`. Never an empty cell. |
| **Fast and cheap** | HTTP only, 1 GB of memory, no proxy needed, no browser to warm up. One request per meeting returns the whole card. |

### 📈 How it compares to alternatives

| Feature | This Actor | Typical racecard scrapers | By hand |
|---|---|---|---|
| Fields per runner | 58 | 10 to 20 | Whatever you copy |
| Official Rating, RPR and Topspeed | All three | Usually the Official Rating only | Three columns to transcribe |
| Betting forecast price | Fraction and decimal | Sometimes | Yes |
| Full going statement with GoingStick | Yes | Rarely | Yes |
| Silks image URL | Yes | Rarely | No |
| Pedigree (sire, dam, damsire) | Yes | Rarely | Behind a click |
| International meetings | GB, IRE, FR, USA, AUS, HK and more | Usually GB and IRE only | Page by page |
| Requests per meeting | 1 | 1 per race | 1 per race |
| Memory and speed | 1 GB, no proxy, no browser | 2 to 4 GB with a browser | Hours |
| Subscriber-only Spotlight, Postdata and Verdict | Not included, and said so plainly | Sometimes promised, rarely delivered | Needs a subscription |

### 🚀 How to use

1. [Create a free Apify account with $5 in credit](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the [Racing Post Racecards Scraper](https://apify.com/parseforge/racing-post-racecards-scraper?fpr=vmoqkp).
3. Keep the defaults for today's full card, or set a date, paste a meeting or race URL, add filters, choose Max Items and click **Start**.
4. Download the dataset as CSV, Excel, JSON or XML from the **Storage** tab, or read it through the API.

Every runner on tomorrow's cards:

```json
{
  "raceDate": "tomorrow",
  "maxItems": 1000
}
```

British and Irish jumps runners only, for a named day:

```json
{
  "raceDate": "2026-09-11",
  "maxItems": 5000,
  "countryCodes": ["GB", "IRE"],
  "raceType": "jumps"
}
```

A single race, including any withdrawn horses:

```json
{
  "startUrls": [{ "url": "https://www.racingpost.com/racecards/15/doncaster/2026-09-10/926640" }],
  "maxItems": 50,
  "includeNonRunners": true
}
```

Free-plan runs return up to 10 runners as a preview. [Upgrade your Apify plan](https://console.apify.com/sign-up?fpr=vmoqkp) to collect up to 1,000,000 rows per run.

### 💼 Business use cases

**📊 Daily form table.** A modeller runs the Actor every morning for today and tomorrow, joins `officialRating`, `rpr`, `topSpeed`, `form` and `weightLbs` onto a horse key, and refits a speed model before the first race.

**🎯 Price your own book.** A trading desk compares `forecastOddsDecimal` against its own model line for every runner on the card, and flags the races where the two disagree most.

**📰 Publish full cards.** A racing site renders every meeting from one dataset: silks, saddlecloth number, draw, jockey, trainer, weights and the race-reader comment, with the going and the prize money in the header.

**🐴 Track a stable or a sire.** A bloodstock analyst filters rows by `trainer`, `owner` or `sire` across every card in Britain and Ireland, and gets an alert the day a horse is declared.

**🌱 Going and draw research.** An analyst collects `goingDetails`, `surface`, `draw` and `distanceYards` over a season to measure how much the draw is worth at each course on each going.

### 🔌 Automating Racing Post Racecards Scraper

Racecards change every day, so schedule the run rather than starting it by hand.

- **Schedule:** set a daily schedule for 07:00 with `raceDate` left at `today`, and a second one the evening before with `tomorrow` if you want the field as soon as it is declared.
- **Webhooks:** fire a webhook on `ACTOR.RUN.SUCCEEDED` to push the dataset into your warehouse or into a Google Sheet.
- **API:** call `run-sync-get-dataset-items` for a one-shot pull straight into a script.
- **Integrations:** the dataset is available to Make, Zapier, Airbyte, n8n and LangChain from the Actor page.

### 🌟 Beyond business use cases

**🏆 Syndicate mornings.** A syndicate manager sends members a table of the day's runners, silks and all, the moment the field is declared.

**📚 Teaching form reading.** A tutor uses `form`, `officialRating` and `comment` side by side to show what each figure is actually telling you.

**🎲 Friendly office sweepstakes.** A sweepstake organiser pulls the runners for a big race, complete with silks and forecast prices, and prints the slips.

**📈 Learning data science.** A student uses a season of racecards as a clean, well-shaped tabular dataset with real categorical and numeric features.

### 🤖 Ask an AI assistant about this scraper

Paste this into ChatGPT, Claude or any assistant that can browse:

> I want to collect British and Irish horse racing racecards as structured data. Explain how the Apify Actor `parseforge/racing-post-racecards-scraper` works, what each of its 58 output fields means, and write me a Python script that calls it through the Apify API for tomorrow's cards and loads the result into a pandas DataFrame.

### ❓ Frequently Asked Questions

#### 🗓️ Which dates can I scrape?

Today and any future date that Racing Post has published. Past dates return no racecards, because a finished race moves to the results section of the site.

#### ⏱️ How far ahead are runners available?

Racing Post lists the meetings and race titles weeks ahead, but the field is declared roughly 48 hours before the off. Ask for a date further out and you will see the meetings listed with no runners yet.

#### 🔗 Which Racing Post URLs can I paste?

A day index such as `/racecards/2026-09-10/`, a meeting such as `/racecards/15/doncaster/2026-09-10/`, or a single race such as `/racecards/15/doncaster/2026-09-10/926640`. A race URL returns only the runners in that race.

#### 🎯 Are these live bookmaker odds?

No. `forecastOdds` is the Racing Post betting forecast, the paper's own prediction of the starting price, and it is what the racecard publishes. Live bookmaker prices arrive on the site over a websocket feed and are not part of this dataset.

#### 🔒 Does this include Spotlight, Postdata, Verdict or the tips?

No. Those are Racing Post Members' Club content and are empty for an anonymous visitor, so the Actor does not include them. The shorter race-reader comment in the `comment` field is public and is included, as are the Official Rating, RPR and Topspeed figures.

#### 🏁 Does it return results, finishing positions or starting prices?

No. This Actor covers racecards, meaning the runners declared before a race. Results live on a separate part of the site with a different shape.

#### 🚪 Why is `draw` sometimes `N/A`?

Jumps races have no starting stalls, so there is no draw. The field is `N/A` there rather than `0`, which would look like a real stall number.

#### ⚠️ What is the difference between `Not Disclosed` and `N/A`?

`Not Disclosed` means Racing Post withholds a value it would normally publish. `N/A` means the field does not apply to that runner or race, such as a draw in a chase or a race class outside Britain.

#### 🌍 Which countries are covered?

Whatever Racing Post lists that day. Britain and Ireland always, and at verification time also France, the United States, Australia, Hong Kong and Peru. Use the country filter to narrow it, or leave it empty for everything.

#### 🚫 Are withdrawn horses included?

Not by default, so every row is a horse still expected to run. Switch on **Include non-runners** and withdrawn horses come back with `isNonRunner` set to `Yes`.

#### 🛡️ Do I need a proxy?

No. Racing Post answers plain HTTP from Apify's datacenter egress and the proxy input is off by default. If you run very large volumes you can switch Apify Proxy on from the input.

#### 🔐 Do I need an API key or a Racing Post account?

No. Only public pages are read, exactly as an anonymous visitor sees them.

#### 📦 How many runners can I collect?

Free-plan runs return 10 rows as a preview. Paid plans go up to 1,000,000 rows per run, which is far more than a single day of racing carries.

#### ⏰ Can I run this on a schedule?

Yes. A daily schedule at 07:00 with `raceDate` set to `today` keeps a warehouse current, and an evening run with `tomorrow` catches the field as soon as it is declared.

#### 📄 What output formats are supported?

CSV, Excel, JSON, XML, JSONL and RSS, from the Storage tab or through the API.

#### ❌ What happens when a request fails?

The Actor retries up to five times with a backoff. If a source still does not answer, it writes one error row naming the source and continues; error rows are never charged.

### 🔌 Integrate with any app

The dataset is available through the Apify API the moment the run finishes. Use the `run-sync-get-dataset-items` endpoint for one-shot calls, webhooks to trigger downstream jobs, or the Make, Zapier, Airbyte and LangChain integrations listed on the Actor page.

### 🔗 Recommended Actors

- [Sporting Life Scraper](https://apify.com/parseforge/sporting-life-racing-scraper?fpr=vmoqkp)
- [Racing TV Racecards Scraper](https://apify.com/parseforge/racing-tv-racecards-scraper?fpr=vmoqkp)
- [Equibase Scraper](https://apify.com/parseforge/equibase-scraper?fpr=vmoqkp)
- [SportyTrader Scraper](https://apify.com/parseforge/sportytrader-scraper?fpr=vmoqkp)

***

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge?fpr=vmoqkp).

**🆘 Need Help?** [Open our contact form](https://tally.so/r/BzdKgA) with your run ID, your input and what you expected.

> **⚠️ Disclaimer:** This Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Racing Post or Racing Post Ltd. It collects only publicly available data. You are responsible for using the data in compliance with Racing Post's terms of use and applicable data-protection laws.

# Actor input Schema

## `startUrls` (type: `array`):

Racing Post racecard pages. Accepts the racecards index (https://www.racingpost.com/racecards/), a dated day index (https://www.racingpost.com/racecards/2026-09-10/), a meeting (https://www.racingpost.com/racecards/15/doncaster/2026-09-10/) and a single race (https://www.racingpost.com/racecards/15/doncaster/2026-09-10/926640). A URL that already names a date keeps that date.

## `maxItems` (type: `integer`):

Maximum runner rows to return. Free users: limited to 10 items (preview). Paid users: optional, up to 1,000,000 items.

## `raceDate` (type: `string`):

Day to collect, as today, tomorrow or YYYY-MM-DD. Racing Post publishes racecards for today and the days ahead only; past dates return no cards, and fields are declared about 48 hours before the off.

## `countryCodes` (type: `array`):

Keep only meetings staged in these countries. Leave empty for every country Racing Post lists that day.

## `raceType` (type: `string`):

Keep only Flat races (turf and all-weather) or only Jumps races (hurdle, chase and National Hunt flat).

## `includeNonRunners` (type: `boolean`):

Add horses already withdrawn from a race. Off by default, so every row is a horse still expected to run.

## `proxyConfiguration` (type: `object`):

Apify proxy settings.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.racingpost.com/racecards/"
    }
  ],
  "maxItems": 10,
  "raceDate": "today",
  "countryCodes": [],
  "raceType": "any",
  "includeNonRunners": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

Key fields: silks, horse, course, off time, race, distance, going, number, draw, jockey, trainer, form, Official Rating, forecast odds

## `fullData` (type: `string`):

Complete dataset with all 58 fields per runner

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "startUrls": [
        {
            "url": "https://www.racingpost.com/racecards/"
        }
    ],
    "maxItems": 10,
    "raceDate": "today"
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/racing-post-racecards-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "startUrls": [{ "url": "https://www.racingpost.com/racecards/" }],
    "maxItems": 10,
    "raceDate": "today",
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/racing-post-racecards-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "startUrls": [
    {
      "url": "https://www.racingpost.com/racecards/"
    }
  ],
  "maxItems": 10,
  "raceDate": "today"
}' |
apify call parseforge/racing-post-racecards-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parseforge/racing-post-racecards-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/E1R2FoiSzSACb0FFF/builds/7ZjantBek66V4Lxeo/openapi.json