# Zeturf.fr Scraper (`lexis-solutions/zeturf-scraper`) Actor

Scrape horse racing data from Zeturf.fr—race results, reports, programme schedules, statuses, favorites beaten, and statistics. Ideal for enthusiasts, bettors, and researchers. Fast, structured, and customizable JSON extraction from France’s premier horse racing platform.

- **URL**: https://apify.com/lexis-solutions/zeturf-scraper.md
- **Developed by:** [Lexis Solutions](https://apify.com/lexis-solutions) (community)
- **Categories:** Other
- **Stats:** 29 total users, 1 monthly users, 100.0% runs succeeded, 3 bookmarks
- **User rating**: No ratings yet

## Pricing

$29.00/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#rental-actors

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## Zeturf.fr Scraper

![banner](https://i.ibb.co/vCjcq2hW/zeturf.png)

Automate horse racing data extraction from Zeturf.fr, France's premier horse racing betting platform. This powerful scraper collects comprehensive race results, reports, and programme data including race statuses, favorites, and detailed race information across all French and international racecourses. Perfect for horse racing enthusiasts, bettors analyzing race patterns, and researchers studying French horse racing statistics. Get structured data in JSON format with detailed information about race results, favorites beaten, and horses to remember.

👋 Welcome to the Zeturf.fr Scraper, an actor designed to help you gather horse racing data from zeturf.fr! With this actor, you can easily extract race results, reports, and programme information from France's leading horse racing platform.

### Introduction

The Zeturf.fr Scraper is a web scraping tool designed to extract horse racing data from zeturf.fr. It was created to make it easier for horse racing enthusiasts, bettors, and researchers to access and analyze race results, programme data, and racing statistics from France's premier horse racing platform.

### Use Cases

Here are some typical scenarios in which the Zeturf.fr Scraper can be useful:

- **Horse Racing Enthusiasts** can use the scraper to track race results and analyze performance patterns
- **Bettors** can use the scraper to monitor race outcomes, favorites beaten, and horses to remember for future betting
- **Researchers** can use the scraper to study French horse racing statistics and trends
- **Data Analysts** can use the scraper to build comprehensive databases of French horse racing information

### Input 📥

To use this actor, you need to provide the following input:

- Field: **startUrls**
  - Type: array
  - Required: Yes
  - Description: URLs to start scraping from

```json
{
  "startUrls": [{ "url": "https://www.zeturf.fr/en/resultats-et-rapports" }]
}
````

### Output 📤

An example output looks like this:

```json
{
  "url": "https://www.zeturf.fr/en/resultats-et-rapports",
  "title": "Results & Reports for the races of 9/23/25",
  "extractedAt": "2025-09-23T14:54:10.768Z",
  "summary": {
    "totalProgrammes": 3,
    "totalRaces": 41,
    "racesByStatus": {
      "In progress": 2,
      "Coming soon": 4,
      "Completed": 34,
      "Canceled": 1
    }
  },
  "programmeData": [
    {
      "date": "TUESDAY 23 SEPTEMBER",
      "tableData": [
        {
          "numero": "R3",
          "nom": "VINCENNES",
          "statut": "In progress",
          "nb-courses": "8",
          "next_step": "Results"
        },
        {
          "numero": "R1",
          "nom": "AUTEUIL",
          "statut": "Completed",
          "nb-courses": "8",
          "favoris-battus": "CANNDARIAN, KRISTAL DU SEUIL, OLYMPIC STORY, SAHARIENNE, JACHAR",
          "a-retenir": "SO RISKY, BINISEGARRA, SILVER BUCKLE, PAS DE QUARTIER, KING PINEAU",
          "next_step": "Results"
        }
      ],
      "total": 12
    }
  ]
}
```

### What data can the Zeturf.fr Scraper extract?

The Zeturf.fr Scraper extracts comprehensive horse racing data including:

- **Race Results**: Complete race outcomes with winners and placements
- **Programme Data**: Daily race schedules organized by date and racecourse
- **Race Status**: Current status of races (In progress, Coming soon, Completed, Canceled)
- **Favorites Beaten**: Information about favorite horses that didn't win
- **Horses to Remember**: Notable horses that performed well
- **Race Statistics**: Total programmes, races, and status breakdowns

### Why use the Zeturf.fr Scraper?

- ⚡️ **Fast** - The scraper efficiently handles complex race data and multiple racecourses.

- 🤙 **Easy to use** - Simply input the URL and let the scraper handle the complexities of French horse racing data.

- 🏇 **Comprehensive** - Extracts all available race data including results, favorites, and programme information.

- ☑️ **Well-Maintained** - The scraper is maintained by the Lexis Solutions team, ensuring reliable performance.

### Limitations

- The scraper focuses on the results and reports page structure
- Historical data availability depends on Zeturf.fr's data retention policies

### FAQ 💬

- **What is Zeturf.fr?**

  Zeturf.fr is France's leading online horse racing betting platform, offering comprehensive race data, results, and betting opportunities across French and international racecourses.

- **How can I access race data on Zeturf.fr?**

  You can access race data by visiting zeturf.fr and navigating to their results and reports section. The Zeturf.fr scraper automates this process by extracting all available race data.

- **Can I use the Zeturf.fr scraper for betting purposes?**

  The Zeturf.fr scraper is for data extraction and analysis only. It should not be used for automated betting or to interact with betting systems. Ensure you comply with the terms of service of Zeturf.fr when using this actor.

- **What types of race data can the Zeturf.fr scraper find?**

  The scraper can extract any race data available on the results page, including:

  - Race results and outcomes
  - Programme schedules
  - Race status information
  - Favorites beaten
  - Horses to remember
  - Race statistics and summaries

- **What if the website changes?**

  Website changes may affect the scraper's functionality. In such cases, our team will update the scraper to maintain compatibility. We regularly monitor and maintain our scrapers to ensure reliable operation.

### Need to scrape other horse racing platforms?

Here are some other horse racing and betting platform scrapers you might find useful:

- **France 🇫🇷**

  - [LeTrot Scraper](https://apify.com/lexis-solutions/letrot-com-scraper) - French trotting horse racing data and results

- **Australia 🇦🇺**
  - [Sportsbet Scraper](https://apify.com/lexis-solutions/sportsbet-com-au-scraper) - Comprehensive betting data from Australia's leading sports betting platform

***

👀 p.s.

Got feedback or need an extension?

Lexis Solutions is a [certified Apify Partner](https://apify.com/partners/find/find). We can help you with custom solutions or data extraction projects.

Contact us over [Email](mailto:scraping@lexis.solutions) or [LinkedIn](https://www.linkedin.com/company/lexis-solutions)

### Support Our Work 💝

If you're happy with our work and scrapers, you're welcome to leave us a company review [here](https://apify.com/partners/find/lexis-solutions/review) and leave a review for the scrapers you're subscribed to. It will take you less than a minute but it will mean a lot to us!

# Actor input Schema

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

URLs to start with.

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

Your proxy configuration from Apify

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.zeturf.fr/en/resultats-et-rapports"
    }
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "FR"
  }
}
```

# 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.zeturf.fr/en/resultats-et-rapports"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("lexis-solutions/zeturf-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.zeturf.fr/en/resultats-et-rapports" }] }

# Run the Actor and wait for it to finish
run = client.actor("lexis-solutions/zeturf-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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.zeturf.fr/en/resultats-et-rapports"
    }
  ]
}' |
apify call lexis-solutions/zeturf-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=lexis-solutions/zeturf-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Zeturf.fr Scraper",
        "description": "Scrape horse racing data from Zeturf.fr—race results, reports, programme schedules, statuses, favorites beaten, and statistics. Ideal for enthusiasts, bettors, and researchers. Fast, structured, and customizable JSON extraction from France’s premier horse racing platform.",
        "version": "0.0",
        "x-build-id": "RIrL6PWoKFvc5FhVQ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/lexis-solutions~zeturf-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-lexis-solutions-zeturf-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/lexis-solutions~zeturf-scraper/runs": {
            "post": {
                "operationId": "runs-sync-lexis-solutions-zeturf-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/lexis-solutions~zeturf-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-lexis-solutions-zeturf-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "startUrls",
                    "proxyConfiguration"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "URLs to start with.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Your proxy configuration from Apify",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "FR"
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```