# PokerStars Sports France Odds Scraper API (`oddsfrance/pokerstars-sports-odds-scraper`) Actor

PokerStars Sports France odds API: match result, money line, totals and handicaps from pokerstars.fr for football, tennis, basketball, ice hockey, NFL, MMA and boxing. Clean rows, no subscription, pay per row. Export JSON, CSV, Excel or Google Sheets.

- **URL**: https://apify.com/oddsfrance/pokerstars-sports-odds-scraper.md
- **Developed by:** [OddsFrance](https://apify.com/oddsfrance) (community)
- **Categories:** Sports, Developer tools, Automation
- **Features:** Limited permissions
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## PokerStars Sports France Odds Scraper API

A **PokerStars Sports France odds API** without a subscription: match result, money line, totals and handicaps from pokerstars.fr as flat rows, and you pay only for the rows you keep.

Get the odds listed on the public pages of **PokerStars Sports France** (pokerstars.fr/sports), as clean rows ready for a spreadsheet, a database or a model: match result, money line, totals and handicaps when the page shows them.

### Why this actor

- **Totals and handicaps** on basketball, ice hockey and American football, not just the match result.
- **PokerStars Sports France is not covered by The Odds API** (checked on 12 November 2026).
- **7 sports**: football, tennis, basketball, ice hockey, American football, MMA, boxing.
- **No subscription**: no monthly plan, no credits to manage. Each run is billed on the rows it saves, and `maxItems` caps the bill.
- **Flat rows, not nested JSON**: one row per outcome, the same 19 fields every time, decimal odds as numbers. Opens directly in Excel or Google Sheets.

### Quick start

1. Click **Try for free** (or **Start**). The default input reads football and finishes in 5 to 35 seconds.
2. Open the **Output** tab: one row per outcome, with competition, teams, start time and odds.
3. Download as CSV, Excel or JSON, or call the actor from your code (examples below).
4. Need fresh odds every hour? Save your input as a task and add a **Schedule**.

### Use cases

- **Betting tips and affiliate sites**: show today's French odds next to your predictions, refreshed by a schedule, without paying for a full odds feed.
- **Value betting and odds comparison**: compare the same match across bookmakers (or use the French Bookmakers Odds actor for three sites in one run), spot the best price and the bookmaker margin.
- **Prediction models and research**: schedule a run every hour or every day and keep each dataset to build your own odds history (opening price, closing price, line moves).
- **Telegram or Discord bots**: send the odds of tonight's matches to a channel with n8n or Make (Apify node, then Telegram or Discord node).
- **Dashboards in Google Sheets or Looker Studio**: one tab per run, refreshed automatically.

### What you get

- Website: pokerstars.fr/sports.
- Sports: football, tennis, basketball, ice hockey, American football, MMA, boxing. Other sports are not offered because their public page does not carry the odds in its HTML.
- Markets: 1X2 or match winner, plus totals (over/under) and handicaps when the sport page lists them (basketball, ice hockey, American football); boxing fights may appear as `other`.
- Pre-match by default; set `includeLive` to also keep events in play that the page lists.
- One row per outcome, the same 19 fields in every row (table below), decimal odds as numbers, times in UTC.

### How it works

The actor opens the sport page and its match list page with a plain HTTP request, the way a browser loads it, and reads the odds that the page already contains. It reads `robots.txt` first and never opens a disallowed path, sends at most one request every 2 seconds to each website, uses no login, no cookies and no proxy. If a site answers with a block (HTTP 403 or 429, captcha page), the run stops at once with a clear message, without retrying. A default run takes 5 to 35 seconds.

### Input

| Field | Type | Default | Description |
| --- | --- | --- | --- |
| `sports` | array | `["football"]` | Sports to read (list in the input form). |
| `competitions` | array | empty | Optional text filters on the competition name, e.g. `Ligue 1`, `NBA`. Empty keeps all. |
| `markets` | array | `match_winner`, `1x2` | Market types to keep. |
| `includeLive` | boolean | `false` | Also keep events already in play. |
| `maxItems` | integer | `200` | Maximum number of rows saved (and paid). |

Example input:

```json
{
  "sports": [
    "basketball",
    "ice_hockey"
  ],
  "markets": [
    "match_winner",
    "handicap",
    "over_under"
  ],
  "includeLive": false,
  "maxItems": 300
}
```

### Output

Three rows copied from a real run of this actor (run on Apify, 2026-11-12):

```json
[
  {
    "bookmaker": "PokerStars Sports",
    "bookmakerCountry": "FR",
    "sport": "tennis",
    "competition": "ATP Stockholm 2026",
    "country": null,
    "eventId": "36309475",
    "eventName": "Musetti - Humbert",
    "homeTeam": "Lorenzo Musetti",
    "awayTeam": "Ugo Humbert",
    "startTime": "2026-11-12T19:20:00Z",
    "isLive": false,
    "marketType": "match_winner",
    "marketName": "Cotes du match",
    "outcome": "home",
    "outcomeName": "Lorenzo Musetti",
    "line": null,
    "oddsDecimal": 1.44,
    "scrapedAt": "2026-11-12T19:16:34Z",
    "sourceUrl": "https://www.pokerstars.fr/sports/tennis/2/"
  },
  {
    "bookmaker": "PokerStars Sports",
    "bookmakerCountry": "FR",
    "sport": "basketball",
    "competition": "NBA",
    "country": null,
    "eventId": "36303942",
    "eventName": "Detroit Pistons @ Washington Wizards",
    "homeTeam": "Washington Wizards",
    "awayTeam": "Detroit Pistons",
    "startTime": "2026-11-13T00:10:00Z",
    "isLive": false,
    "marketType": "handicap",
    "marketName": "Handicap",
    "outcome": "away",
    "outcomeName": "Detroit Pistons",
    "line": -10.5,
    "oddsDecimal": 1.83,
    "scrapedAt": "2026-11-12T19:16:42Z",
    "sourceUrl": "https://www.pokerstars.fr/sports/basketball/7522/"
  },
  {
    "bookmaker": "PokerStars Sports",
    "bookmakerCountry": "FR",
    "sport": "basketball",
    "competition": "NBA",
    "country": null,
    "eventId": "36303942",
    "eventName": "Detroit Pistons @ Washington Wizards",
    "homeTeam": "Washington Wizards",
    "awayTeam": "Detroit Pistons",
    "startTime": "2026-11-13T00:10:00Z",
    "isLive": false,
    "marketType": "over_under",
    "marketName": "Total de points",
    "outcome": "over",
    "outcomeName": "Plus de",
    "line": 220.5,
    "oddsDecimal": 1.83,
    "scrapedAt": "2026-11-12T19:16:42Z",
    "sourceUrl": "https://www.pokerstars.fr/sports/basketball/7522/"
  }
]
```

| Field | Description |
| --- | --- |
| `bookmaker` | Bookmaker name (Winamax, NetBet, PokerStars Sports). |
| `bookmakerCountry` | Country of the bookmaker website that was read (FR, ES, DE). |
| `sport` | Normalized sport (football, tennis, basketball, ice_hockey, ...). |
| `competition` | Competition name as shown on the site (tennis circuit prefixed, e.g. ATP, WTA). |
| `country` | Country or region of the competition when the site gives one, else null. |
| `eventId` | Event id on the bookmaker site (not shared between bookmakers). |
| `eventName` | Event name as shown on the site. |
| `homeTeam` | Home team, or first participant for individual sports. |
| `awayTeam` | Away team, or second participant. |
| `startTime` | Start time, ISO 8601 UTC. |
| `isLive` | true if the event was in play when read. |
| `marketType` | Normalized market: match_winner, 1x2, over_under, handicap, both_teams_to_score, outright, other. |
| `marketName` | Market label on the site (original language). |
| `outcome` | Normalized outcome: home, draw, away, over, under, yes, no, or the participant name. |
| `outcomeName` | Outcome label on the site. |
| `line` | Handicap or total line, else null. |
| `oddsDecimal` | Decimal odds (number). |
| `scrapedAt` | Time the page was read, ISO 8601 UTC. |
| `sourceUrl` | Public page the row was read from. |

Labels (competition, market, outcome names) stay in the language of the website. You can download the dataset as JSON, CSV, Excel or XML from the run page or through the API.

### Price

Free to use during the launch: there is no actor fee, you only pay the Apify platform usage of your run (a default run of up to 200 rows uses well under $0.01, covered by the free Apify plan). The planned price is **$1.50 per 1,000 rows** saved to the dataset, platform usage included; Apify announces any price change to users 14 days before it applies.

### Use it from your code, Google Sheets, n8n or Make

Run the actor and get the rows in one HTTP call (replace `YOUR_API_TOKEN` with your Apify API token, from Console > Settings > API & Integrations):

```bash
curl -X POST "https://api.apify.com/v2/acts/oddsfrance~pokerstars-sports-odds-scraper/run-sync-get-dataset-items?token=YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"sports": ["basketball", "ice_hockey"], "markets": ["match_winner", "handicap", "over_under"], "includeLive": false, "maxItems": 300}'
```

Python (`pip install apify-client`, version 3.x):

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")
run = client.actor("oddsfrance/pokerstars-sports-odds-scraper").call(run_input={"sports": ["basketball", "ice_hockey"], "markets": ["match_winner", "handicap", "over_under"], "includeLive": False, "maxItems": 300})
for row in client.dataset(run.default_dataset_id).iterate_items():
    print(row["eventName"], row["outcome"], row["oddsDecimal"])
```

JavaScript or TypeScript (`npm install apify-client`):

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

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });
const run = await client.actor('oddsfrance/pokerstars-sports-odds-scraper').call({"sports": ["basketball", "ice_hockey"], "markets": ["match_winner", "handicap", "over_under"], "includeLive": false, "maxItems": 300});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.slice(0, 5));
```

- **Google Sheets**: add the Apify integration for Google Sheets to a task (Integrations tab), or import the CSV export link of the dataset with `=IMPORTDATA("...")`.
- **n8n**: the official Apify node runs the actor and returns the rows; chain a Google Sheets, Telegram or Discord node.
- **Make (Integromat)** and **Zapier**: the Apify app has "Run an Actor" and "Get dataset items" modules.
- **Schedules and webhooks**: run it every few minutes or hours with an Apify schedule; a webhook can call your server when each run finishes.
- **AI agents**: the actor is available through the Apify MCP server, so Claude, ChatGPT or Cursor can call it as a tool.

### Recipe: build your own odds history

Save your input as a task, add a schedule (for example every hour), then rebuild the price moves from the last runs. Tested on real runs of this actor:

```python
## Odds history (apify-client 3.x): run the actor on an Apify schedule (e.g. every hour), then rebuild the price moves.
import pandas as pd
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")
runs = client.actor("oddsfrance/pokerstars-sports-odds-scraper").runs().list(desc=True, limit=24, status="SUCCEEDED").items
history = pd.concat(
    [pd.DataFrame(client.dataset(r.default_dataset_id).list_items().items) for r in runs],
    ignore_index=True,
).sort_values("scrapedAt")

odds = history.groupby(["bookmakerCountry", "eventName", "marketType", "outcome"])["oddsDecimal"]
moves = pd.DataFrame({"first": odds.first(), "last": odds.last(), "snapshots": odds.size()})
moves["change"] = moves["last"] - moves["first"]
print(moves[moves["snapshots"] > 1].sort_values("change").head(10))
```

### Compared with The Odds API

The Odds API is a good product with a much wider bookmaker list. This actor is narrower and cheaper for the French market. Facts checked on their public pages on 12 November 2026:

| | This actor | The Odds API |
| --- | --- | --- |
| Pricing | Pay per row, no plan (free during launch) | Monthly plans: 500 free credits, then from $30 per month |
| Winamax France and Germany | Yes | Yes |
| Winamax Spain | Yes | Not in their bookmaker list |
| NetBet France | Yes | Yes |
| PokerStars Sports France | Yes | Not in their bookmaker list |
| Markets | Every market the public sport page lists | h2h, spreads, totals; more on selected sports |
| Odds history | Build your own with a schedule | Included in paid plans |
| Format | Flat rows (CSV, Excel ready) | Nested JSON per event |
| Worldwide coverage (US, UK, AU books) | No, French market only | Yes |

Pick The Odds API for many bookmakers worldwide or a ready-made history. Pick this actor for French bookmakers, no subscription, and rows you can open in a spreadsheet.

### Limits

- Odds move all the time: a row is a snapshot at `scrapedAt`, not a live feed. Live events are kept only when the page lists them, with no guarantee of latency or completeness.
- Only what the public page shows is returned. Fewer rows than `maxItems` means fewer open markets.
- The actor depends on the structure of the website. If the site changes or blocks Apify servers, runs can fail or return no rows until the actor is updated; the run log says why. The actor is tested every day on Apify.
- Event ids, team names and competition names are the bookmaker's own; there is no cross-site id.

### FAQ

**How fresh are the odds?** They are read when the run starts. A default run takes 5 to 35 seconds; schedule it as often as you need.

**Can I get only Ligue 1, the Premier League or the NBA?** Yes: put the name in `competitions` (case-insensitive text match).

**Can I get historical odds?** Not from the past, but every scheduled run is kept as a dataset, so your history starts with your first run (recipe above).

**Does it use proxies or bypass protections?** No. It reads public pages at a slow pace, follows `robots.txt` and stops when a site refuses access.

**Why not Betclic, Unibet or Parions Sport?** Their pages refuse requests from Apify servers or are protected by an anti-bot service, and this actor never bypasses a protection.

**Why did my run stop early?** The status message says it: a site answered with a block (403, 429 or captcha), or the spending limit of the run was reached. Rows saved before that are kept.

**Is a row the same as a match?** No. One row is one outcome: a 1X2 match gives three rows.

**Something is missing or broken?** Open an issue in the Issues tab of this actor.

### Other OddsFrance actors

- [Winamax France, Spain and Germany](https://apify.com/oddsfrance/winamax-odds-scraper)
- [NetBet France](https://apify.com/oddsfrance/netbet-odds-scraper)
- [Winamax, NetBet and PokerStars Sports in one dataset](https://apify.com/oddsfrance/french-sportsbooks-odds)

### Legal and responsible use

- This actor is not affiliated with, endorsed by or sponsored by Winamax, NetBet, PokerStars or any bookmaker. Brand names belong to their owners and are used only to describe the source of the data.
- It collects public data only: odds that anyone can see on the website without an account. It collects no personal data.
- The data is provided for information purposes only, with no guarantee of accuracy or availability.
- You are responsible for complying with the terms of the websites and with the law of your country when you use this actor and its data.
- This actor does not encourage gambling and gives no betting advice. It promises no profit and no arbitrage. Gambling is for adults (18+) only and can be addictive; in France, help is available at joueurs-info-service.fr (09 74 75 13 13).

### En français

**API des cotes PokerStars Sports** (pokerstars.fr) : résultat du match, vainqueur, totaux (plus/moins) et handicaps en lignes prêtes pour Excel, Google Sheets ou un modèle. NBA, NHL, NFL, Ligue 1. Sans abonnement, vous payez à la ligne.

### En español

**API de cuotas PokerStars Sports Francia**: resultado, ganador, totales y hándicaps en filas listas para Excel o Google Sheets. Sin suscripción.

# Actor input Schema

## `sports` (type: `array`):

Sports to read, one page per sport. Keep the list short for fast, cheap runs.

## `competitions` (type: `array`):

Optional. Keep only events whose competition or country contains one of these words (case-insensitive), e.g. "Ligue 1", "Premier League", "ATP". Empty = every competition on the page.

## `markets` (type: `array`):

Normalised market types to keep. Only markets shown on the public sport pages can be returned (see the README).

## `includeLive` (type: `boolean`):

Also return events already in play, if the page shows them. Live odds move fast: treat them as a snapshot.

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

Maximum number of odds rows (one row = one outcome of one market). The run stops reading pages once it is reached.

## Actor input object example

```json
{
  "sports": [
    "football"
  ],
  "competitions": [],
  "markets": [
    "match_winner",
    "1x2"
  ],
  "includeLive": false,
  "maxItems": 200
}
```

# Actor output Schema

## `results` (type: `string`):

Odds rows of the run, one per (event, market, outcome, bookmaker).

# 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 = {
    "sports": [
        "football"
    ],
    "competitions": [],
    "markets": [
        "match_winner",
        "1x2"
    ],
    "maxItems": 200
};

// Run the Actor and wait for it to finish
const run = await client.actor("oddsfrance/pokerstars-sports-odds-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 = {
    "sports": ["football"],
    "competitions": [],
    "markets": [
        "match_winner",
        "1x2",
    ],
    "maxItems": 200,
}

# Run the Actor and wait for it to finish
run = client.actor("oddsfrance/pokerstars-sports-odds-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 '{
  "sports": [
    "football"
  ],
  "competitions": [],
  "markets": [
    "match_winner",
    "1x2"
  ],
  "maxItems": 200
}' |
apify call oddsfrance/pokerstars-sports-odds-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,oddsfrance/pokerstars-sports-odds-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/MoreeV2Hirkc8uIhI/builds/alnwsSWnUGt1Am9m5/openapi.json