# Tennis Scores & Stats API (`lergassy/tennis-scores-api`) Actor

Live tennis scores, daily schedules, results, match statistics, point by point, betting odds, ATP and WTA rankings, player profiles and tournament draws for ATP, WTA, Challenger, ITF and UTR. One flat row per match with a ready summary. Export data, run via API, schedule, or use with AI agents.

- **URL**: https://apify.com/lergassy/tennis-scores-api.md
- **Developed by:** [Matvey](https://apify.com/lergassy) (community)
- **Categories:** Sports, Agents, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.80 / 1,000 matches

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

**Tennis Scores & Stats API** returns live tennis scores, the full daily schedule, results, match statistics, point-by-point records, betting odds, ATP and WTA rankings, player profiles and tournament draws for **ATP, WTA, Challenger, WTA 125, ITF and UTR** events — one flat row per match with players, countries, rankings, seeds, set scores, the current game and a one-sentence summary you can drop straight into a message, a spreadsheet or a prompt. No API key, no browser, no login: the Actor reads the same JSON feed the SofaScore site uses and a whole day of ATP and WTA matches costs a fraction of a cent.

![One run of Tennis Scores & Stats API: today’s ATP and WTA card with scores, status and surface.](https://raw.githubusercontent.com/lergassy/apify-actor-assets/main/tennis-scores-api/tennis-scores-api-output-table.png)

Pick what you want — the schedule for a date, matches in play now, one match in depth, a player, a tournament, the rankings or a name lookup — and click Start. Export JSON, CSV or Excel, run it on a schedule, or call it from the API, n8n, Make or an AI agent through MCP.

### What is Tennis Scores & Stats API?

It is a **tennis data API** for people who need scores and match data as a table rather than a web page: betting and trading models, fantasy tools, Discord and Telegram bots, dashboards, newsletters, coaching and scouting research, and AI agents that get asked "who is playing today", "did Sinner win" or "what are the odds for the final". The official tour feeds are licensed to broadcasters and cost thousands a month; this Actor gives you the public SofaScore data — the most complete free source there is — as clean rows at pay-per-result prices.

- **Every tour in one place**: ATP, WTA, ATP Challenger, WTA 125, ITF men and women, UTR, Davis Cup, Billie Jean King Cup, United Cup and exhibitions. Grand Slams sit under ATP and WTA.
- **Live scores** with sets, games, the points of the current game and who served first; **results** with set scores and tiebreaks; **schedules** with start times in UTC, round, surface and seeds.
- **Match statistics** per match and per set: aces, double faults, first-serve percentage, points won on first and second serve, break points saved and converted, return points, longest streaks, tiebreaks.
- **Point by point**: every game with its point sequence, the server and who won the game — the raw material for pressure-point and momentum models.
- **Betting odds**: pre-match and live match-winner odds in decimal and fractional form, opening and current, plus every other market SofaScore lists.
- **Rankings**: ATP and WTA lists up to 500 deep with points, previous rank, best rank and tournaments played, and the projected *live* ranking on player profiles.
- **Players**: age, country, plays left or right, height, weight, turned pro, prize money for the season and career, current tournament, next match, and recent results.
- **Tournaments**: surface, ranking points, dates, title holder, the matches of the current edition and the whole draw as bracket blocks.
- **Search** by name to get the ids you need for player, tournament and match modes.
- **Pure HTTP**: no headless browser, so a run finishes in seconds.

### What data can Tennis Scores & Stats API extract?

#### Matches — schedule, live and results

| Field | Example |
|---|---|
| `tour`, `tournament`, `tournamentId`, `round`, `groundType` | ATP · US Open, New York, USA · 2449 · Round of 32 · Hardcourt outdoor |
| `status`, `statusDetail`, `startTime`, `date` | live · 2nd set · 2026-09-06T15:30:00Z · 2026-09-06 |
| `homePlayer`, `homePlayerId`, `homeCountry`, `homeRanking`, `homeSeed` | Taylor Fritz · 136042 · US · 10 · 9 |
| `awayPlayer`, `awayPlayerId`, `awayCountry`, `awayRanking`, `awaySeed` | Francisco Cerundolo · 162689 · AR · 19 · null |
| `matchType`, `homePartners`, `awayPartners` | doubles · \["Marcelo Demoliner", "Ray Ho"] · \["Nathaniel Lammons", "Jackson Withrow"] |
| `homeSets`, `awaySets`, `score`, `sets` | 1 · 1 · 6-4 3-6 · \[{set: 1, home: 6, away: 4, …}] |
| `currentGamePoints`, `currentSet`, `firstToServe` | 30-40 · 3 · home |
| `winner`, `winnerName`, `durationMinutes` | home · Taylor Fritz · 148 |
| `summary` | "Taylor Fritz (US) vs Francisco Cerundolo (AR), US Open Round of 32 — 2nd set, 6-4 3-3 (30-40)" |
| `matchUrl`, `eventId` | SofaScore match page · 16901526 |

Optional blocks on every match row: `odds`, `statistics`, `headToHead`, `fanVotes`, `pointByPoint`, `venue`.

#### Rankings

`tour`, `rank`, `previousRank`, `bestRank`, `points`, `previousPoints`, `tournamentsPlayed`, `player`, `playerId`, `country`, `playerUrl`, `rankingUpdatedAt`.

#### Players

`player`, `playerId`, `country`, `tour`, `ranking`, `bestRanking`, `rankingPoints`, `liveRanking`, `liveRankingPoints`, `age`, `birthDate`, `birthplace`, `residence`, `plays`, `heightMeters`, `weightKg`, `turnedPro`, `prizeMoneyCurrentSeason`, `prizeMoneyCareer`, `prizeCurrency`, `currentTournament`, `nextMatch`, `userCount` — followed by the player's recent matches as match rows.

#### Tournaments and draws

Tournament: `tournament`, `tournamentId`, `tour`, `groundType`, `rankingPointsTournament`, `startDate`, `endDate`, `titleHolder`, `season`, `seasonId`, `tournamentUrl`. Draw block: `round`, `blockOrder`, `homePlayer`, `homeSeed`, `homeWinner`, `awayPlayer`, `awaySeed`, `awayWinner`, `result`, `finished`, `eventId`.

### How much does it cost to get tennis scores?

The Actor uses Apify's **pay-per-event** pricing: you pay per row returned and per optional detail block — nothing per run, per page or per proxy megabyte. Error rows are never charged.

| Event | Price | Per 1,000 |
|---|---|---|
| Match row (schedule, live, results, player and tournament matches) | $0.004 | **$4** |
| Add-on: detail block on a match (odds, statistics or point by point) | $0.006 | **$6** |
| Ranking row | $0.0005 | **$0.50** |
| Player profile | $0.01 | **$10** |
| Tournament record | $0.005 | **$5** |
| Draw block | $0.001 | **$1** |

A day of ATP and WTA matches (about 90 rows) costs $0.36; the ATP top 100 costs $0.05; one match with odds, statistics and point by point costs $0.022. The **Apify Free plan** ($5 monthly credit) covers roughly 1,200 match rows a month. Bronze, Silver and Gold Store tiers get a discount on top.

### How to get tennis scores with Tennis Scores & Stats API

1. Open the Actor and pick **What to get** — Schedule is the default.
2. For a schedule, choose the **Tours** (ATP and WTA are preselected), the **Date** (today by default) and how many **Days ahead**; optionally keep only live, upcoming or finished matches, singles or doubles, or one player's matches.
3. Switch on **odds**, **statistics** or **point by point** if you need them on every match — each adds a request per match and is billed as a detail block.
4. Click **Start**. Results appear in the **Matches** table view; other modes fill the Rankings, Players, Tournaments, Draw and Search views.
5. Download as JSON, CSV or Excel, or read the dataset through the API.

### ⬇️ Input

#### Today's ATP and WTA schedule with live scores

```json
{ "mode": "schedule" }
```

#### The week of a tournament, singles only, with statistics on finished matches

```json
{
    "mode": "schedule",
    "dateFrom": "2026-09-01",
    "days": 6,
    "tours": ["atp", "wta"],
    "status": "finished",
    "matchType": "singles",
    "includeStatistics": true
}
```

#### Matches in play right now, every tour

```json
{ "mode": "live", "tours": [] }
```

#### One match in depth — odds, statistics, head-to-head, fan votes and point by point

```json
{ "mode": "match", "eventIds": ["16901526"], "includePointByPoint": true }
```

#### A player: profile, ranking, next match and last 20 results

```json
{ "mode": "player", "playerIds": ["206570"], "maxMatchesPerPlayer": 20 }
```

#### A tournament with its draw and pre-match odds

```json
{ "mode": "tournament", "tournamentIds": ["2449"], "includeDraw": true, "includeOdds": true }
```

#### ATP and WTA top 100

```json
{ "mode": "rankings", "rankingTour": "both", "rankingTop": 100 }
```

#### Find ids by name

```json
{ "mode": "search", "query": "Alcaraz" }
```

| Field | Description |
|---|---|
| `mode` | `schedule`, `live`, `match`, `player`, `tournament`, `rankings` or `search` |
| `dateFrom`, `days` | Day in UTC and how many more days to include (up to 14) |
| `tours` | `atp`, `wta`, `challenger`, `wta125`, `itf_men`, `itf_women`, `utr_men`, `utr_women`, `davis_cup`, `bjk_cup`, `united_cup`, `exhibition` |
| `status`, `matchType`, `playerName` | Keep only upcoming / live / finished, singles / doubles, or one player's matches |
| `includeOdds`, `includeStatistics`, `includePointByPoint` | Detail blocks on every match ($) |
| `eventIds`, `playerIds`, `tournamentIds` | Ids or SofaScore URLs for match, player and tournament modes |
| `query` | Name to search |
| `rankingTour`, `rankingTop` | `atp`, `wta` or `both`; rows per list (up to 500) |
| `includeDraw` | Draw blocks in tournament mode ($) |
| `maxMatches`, `maxMatchesPerPlayer`, `maxMatchesPerTournament`, `concurrency` | Caps and speed |

Ids are visible on SofaScore URLs and in every row: `eventId` on matches, `homePlayerId` / `awayPlayerId` for players, `tournamentId` for tournaments. **Search** mode returns them by name.

### ⬆️ Output

#### Match

```json
{
    "type": "match",
    "eventId": 16385361,
    "matchUrl": "https://www.sofascore.com/tennis/match/jannik-sinner-alexander-zverev/xZbsWpb",
    "tour": "ATP",
    "tournament": "Wimbledon, London, Great Britain",
    "tournamentId": 2361,
    "round": "Final",
    "groundType": "Grass",
    "matchType": "singles",
    "status": "finished",
    "statusDetail": "Ended",
    "startTime": "2026-07-12T13:00:00Z",
    "homePlayer": "Jannik Sinner", "homePlayerId": 206570, "homeCountry": "IT", "homeRanking": 1, "homeSeed": "1",
    "awayPlayer": "Alexander Zverev", "awayPlayerId": 57163, "awayCountry": "DE", "awayRanking": 3, "awaySeed": "3",
    "homeSets": 3, "awaySets": 1,
    "score": "6-7(7) 7-6(2) 6-3 6-4",
    "sets": [
        { "set": 1, "home": 6, "away": 7, "homeTiebreak": 7, "awayTiebreak": 9 },
        { "set": 2, "home": 7, "away": 6, "homeTiebreak": 7, "awayTiebreak": 2 },
        { "set": 3, "home": 6, "away": 3, "homeTiebreak": null, "awayTiebreak": null },
        { "set": 4, "home": 6, "away": 4, "homeTiebreak": null, "awayTiebreak": null }
    ],
    "winner": "home",
    "winnerName": "Jannik Sinner",
    "durationMinutes": 226,
    "summary": "Jannik Sinner (IT) vs Alexander Zverev (DE), Wimbledon, London, Great Britain Final — Jannik Sinner won 6-7(7) 7-6(2) 6-3 6-4",
    "statistics": {
        "match": { "aces": { "home": 15, "away": 17 }, "doubleFaults": { "home": 2, "away": 2 }, "firstServeAccuracy": { "home": 87, "away": 105, "homeText": "87/126 (69%)", "awayText": "105/152 (69%)" }, "breakPointsSaved": { "home": 4, "away": 3 } },
        "set1": { "aces": { "home": 4, "away": 6 } }
    },
    "headToHead": { "homeWins": 10, "awayWins": 0 },
    "fanVotes": { "homeVotes": 34789, "awayVotes": 12343, "homeVotePercent": 73.8, "awayVotePercent": 26.2 },
    "pointByPoint": [
        { "set": 1, "game": 1, "gamesHome": 1, "gamesAway": 0, "serving": "home", "gameWonBy": "home", "points": ["15-0", "30-0", "30-15", "40-15", "40-30"] }
    ],
    "scrapedAt": "2026-09-06T14:00:00.000Z"
}
```

Live matches carry `currentGamePoints` (for example `30-40` or `A-40`), `currentSet` and the set scores so far; upcoming matches carry the start time and, with `includeOdds`, the opening and current pre-match odds.

#### Odds block

```json
{
    "prematch": { "homeDecimal": 1.11, "awayDecimal": 6.5, "homeFractional": "11/100", "awayFractional": "11/2", "homeOpeningDecimal": 1.22, "awayOpeningDecimal": 4.333, "suspended": false },
    "live": null,
    "markets": [ { "market": "Full time", "group": "Home/Away", "period": "Match", "isLive": false, "choices": [ { "name": "1", "decimal": 1.11, "opening": 1.22 }, { "name": "2", "decimal": 6.5, "opening": 4.333 } ] } ]
}
```

#### Ranking row

```json
{ "type": "ranking", "tour": "ATP", "rank": 1, "previousRank": 1, "bestRank": 1, "points": 12800, "previousPoints": 12800, "tournamentsPlayed": 19, "player": "Jannik Sinner", "playerId": 206570, "country": "IT", "countryName": "Italy", "playerUrl": "https://www.sofascore.com/team/tennis/sinner-jannik/206570", "rankingUpdatedAt": "2026-09-01T06:35:38Z" }
```

#### Player

```json
{ "type": "player", "playerId": 206570, "player": "Jannik Sinner", "country": "IT", "tour": "ATP", "ranking": 1, "bestRanking": 1, "rankingPoints": 12800, "liveRanking": 1, "liveRankingPoints": 11500, "heightMeters": 1.91, "weightKg": 77, "plays": "right-handed", "turnedPro": 2018, "birthDate": "2001-08-16", "age": 25, "birthplace": "San Candido, Italy", "residence": "Monte Carlo, Monaco", "prizeMoneyCurrentSeason": 10093830, "prizeMoneyCareer": 60540308, "prizeCurrency": "EUR", "currentTournament": "US Open, New York, USA", "nextMatch": { "eventId": 16988400, "tournament": "US Open, New York, USA", "round": "Quarterfinals", "opponent": "Taylor Fritz", "startTime": "2026-09-08T23:00:00Z" } }
```

#### Draw block

```json
{ "type": "draw", "tournament": "US Open, Men", "round": "Round of 128", "blockOrder": 1, "homePlayer": "Alexander Zverev", "homeSeed": "1", "homeWinner": true, "awayPlayer": "Lorenzo Sonego", "awaySeed": null, "awayWinner": false, "result": "3:2", "finished": true, "eventId": 16940149 }
```

Use the **Matches**, **Rankings**, **Players**, **Tournaments**, **Draw** and **Search results** table views in the dataset to browse, or download everything as CSV/Excel.

### Use cases for tennis data

#### Betting models and trading bots

Pull the day's schedule with `includeOdds` in the morning, the live feed every minute during play, and `includePointByPoint` on finished matches to build serve-hold, break-point and momentum features. The `odds` block keeps opening and current prices so you can measure line movement.

#### Fantasy, pools and bracket challenges

Tournament mode with `includeDraw` gives the whole bracket as rows; run it daily to advance winners automatically. Player mode gives form (recent results) and the live ranking.

#### Bots, alerts and newsletters

`summary` is a ready sentence per match; filter on `status: "finished"` and `playerName` to post "Sinner won 6-4 6-3" the moment it happens. `nextMatch` on a player profile tells you when to set the next reminder.

#### Coaching, scouting and research

Statistics per set and the point sequence per game for any match on any tour, including Challenger and ITF where no other free source exists; rankings history through `previousRank` and `bestRank`.

#### Travel content and AI agents

Agents answer "who plays in Cincinnati today", "is Alcaraz seeded" or "what are the odds for the final" from one call — the rows are flat, self-describing and carry the ids for follow-up questions.

### Integrations and tennis API

Run the Actor from the [Apify API](https://docs.apify.com/api/v2) or the JavaScript and Python clients, on a schedule (every minute during play for live scores, daily for schedules and rankings), and connect it to n8n, Make, Zapier, Google Sheets, Slack, Discord or webhooks through Apify integrations.

```bash
curl -X POST "https://api.apify.com/v2/acts/lergassy~tennis-scores-api/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ "mode": "live", "tours": ["atp", "wta"] }'
```

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_TOKEN")
run = client.actor("lergassy/tennis-scores-api").call(run_input={"mode": "schedule", "days": 1, "includeOdds": True})
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(row["summary"], row.get("odds", {}).get("prematch"))
```

#### Use it from Claude, Cursor or any MCP agent

Connect the [Apify MCP server](https://mcp.apify.com) and let the agent call `lergassy/tennis-scores-api` with the inputs above — the modes map onto natural questions (schedule → "who plays today", player → "how is Sinner doing", match → "give me the stats of the final").

### 🤖 For AI Agents & LLM Apps

Compact reference for agents calling this Actor through the [Apify MCP server](https://mcp.apify.com) or the Apify API (`lergassy/tennis-scores-api`).

**Purpose:** live and scheduled tennis matches with scores, players, rankings, seeds, odds, statistics, point by point, rankings, player profiles and tournament draws for every professional tour. Use it to answer "who is playing today / now", "did X win and what was the score", "what are the odds", "who is number one", "when is X's next match" and "show me the draw".

**Minimal input:**

```json
{ "mode": "schedule" }
```

**Output:** one row per match — `type`, `eventId`, `matchUrl`, `tour`, `tournament`, `tournamentId`, `round`, `groundType`, `matchType`, `status`, `statusDetail`, `startTime`, `date`, `homePlayer`, `homePlayerId`, `homeCountry`, `homeRanking`, `homeSeed`, `homePartners`, `awayPlayer`, `awayPlayerId`, `awayCountry`, `awayRanking`, `awaySeed`, `awayPartners`, `homeSets`, `awaySets`, `score`, `sets[]`, `currentGamePoints`, `currentSet`, `firstToServe`, `winner`, `winnerName`, `durationMinutes`, `summary`, plus optional `odds`, `statistics`, `headToHead`, `fanVotes`, `pointByPoint`, `venue`. Other modes return `ranking`, `player`, `tournament`, `draw` and `search` rows with the fields listed above.

**Behaviors an agent should know:**

- Dates are UTC days. `status` is `upcoming`, `live` or `finished`; `statusDetail` carries SofaScore's wording (`2nd set`, `Walkover`, `Retired`).
- **Quote `summary`** when the user wants a sentence; quote `score` and `winnerName` when they want the result. `currentGamePoints` exists only while a match is live.
- Ids chain: `homePlayerId` / `awayPlayerId` → `playerIds` in player mode; `tournamentId` → `tournamentIds`; `eventId` → `eventIds` for statistics, odds and point by point. Unknown name? Run `search` first.
- Doubles rows name the pair (`Demoliner M / Ho R`) and list both players in `homePartners` / `awayPartners`; use `matchType: "singles"` to skip them.
- `includeOdds`, `includeStatistics` and `includePointByPoint` each add requests and cost per match — turn them on only when the question needs them; match mode fetches all of them for the ids given.
- Rankings are official weekly lists; `liveRanking` on a player profile is the projection from the current week's results.
- Rows are a snapshot at run time. For live scores schedule the run every minute rather than polling inside one run.

### ❓ FAQ

#### Is it legal to scrape tennis scores?

Scores, schedules, rankings and statistics are facts, and this Actor reads only public, non-personal data that SofaScore shows to every visitor. Respect the site's terms and your local law for commercial use, especially around betting — consult a lawyer if unsure.

#### Is there an official ATP or WTA API?

Not for the public. The tours license their data to broadcasters and betting companies. This Actor is a **tennis scores API alternative** built on public data.

#### Can I use Tennis Scores & Stats API with the Apify API?

Yes — start runs, pass input and read the dataset with any HTTP client or the official JavaScript and Python clients. See the snippets above.

#### Can I use it through an MCP server?

Yes. Add the Apify MCP server to Claude, Cursor, ChatGPT or your own agent and call `lergassy/tennis-scores-api`.

#### Can I integrate it with other apps?

Yes — n8n, Make, Zapier, Google Sheets, Slack, Discord, Airtable and webhooks through Apify integrations, or a scheduled run that posts the dataset anywhere.

#### How fresh are live scores?

Each run is a snapshot of SofaScore's live feed at that moment, usually within seconds of the court. Schedule the live mode every minute during sessions you care about.

#### Which tours and tournaments are covered?

Everything SofaScore lists: all four Grand Slams, ATP Masters 1000 down to 250, WTA 1000 to 250, WTA 125, ATP Challenger, ITF World Tennis Tour men and women, UTR Pro, Davis Cup, Billie Jean King Cup, United Cup, Laver Cup and exhibitions.

#### Do I get doubles?

Yes — doubles matches are rows with `matchType: "doubles"` and both partners listed. Filter with `matchType` if you only want singles.

#### How do I find a player's or tournament's id?

Run **search** with the name; every result row says which input field the id belongs in. Ids also appear in SofaScore URLs and in every match row.

#### Can I get odds from a specific bookmaker?

The odds block is the market SofaScore displays (its default bookmaker), with opening and current prices and every listed market. It is a reference line for models, not a betting feed.

#### Why is the point-by-point empty for a match?

Point sequences exist for matches with live scoring, which covers ATP, WTA, Challenger and most ITF events. Some ITF and UTR matches are entered set by set, and upcoming matches have no points yet.

#### Do I need proxies?

The Actor uses Apify **Residential** proxies by default because SofaScore blocks datacenter addresses. A day of matches transfers about 250 KB, so the proxy cost is negligible; leave the setting as it is.

#### What happens on an error?

The Actor writes an `error` row with the scope (date, tour or id) instead of failing silently, and you are not charged for it.

### Your feedback

Need another field (serve speeds, rally lengths, historical seasons) or another mode (head-to-head by player pair, weekly ranking history)? Open an issue in the **Issues** tab. If the data helped, a review helps other tennis people find it.

### You might also like

| Actor | What it does |
|---|---|
| [WTA Tennis Scraper](https://apify.com/lergassy/wta-tennis-scraper) | Official WTA data by player: match history with points and prize money, live ranking tables, profiles, calendar |
| [Sports Scores & Schedules API](https://apify.com/lergassy/sports-scores-api) | Scores, schedules, standings, rosters and betting lines for NFL, NBA, MLB, NHL, soccer, UFC, F1 and golf |
| [Google Flights Scraper](https://apify.com/lergassy/google-flights-scraper) | Flight prices, price calendars and booking links from Google Flights |
| [Agoda Reviews Scraper](https://apify.com/lergassy/agoda-reviews-scraper) | Hotel reviews from Agoda, including the Booking.com reviews shown on Agoda |
| [Trip.com Scraper](https://apify.com/lergassy/tripcom-scraper) | Hotels with prices, details and guest reviews from Trip.com |
| [Email & Phone Verifier](https://apify.com/lergassy/email-phone-verifier) | Checks e-mails and phone numbers in bulk: deliverability, disposable and role flags, numbering plan |

# Actor input Schema

## `mode` (type: `string`):

<b>Schedule</b> — every match on a date (and the following days) for the chosen tours: upcoming, live and finished. <b>Live</b> — matches in play right now. <b>Match</b> — full details for specific matches (statistics, odds, head-to-head, point by point). <b>Player</b> — profile, ranking and recent results. <b>Tournament</b> — a tournament's matches and draw. <b>Rankings</b> — the ATP and WTA lists. <b>Search</b> — find player and tournament ids by name.

## `dateFrom` (type: `string`):

Day to list matches for, <code>YYYY-MM-DD</code> in UTC. Leave empty for today.

## `days` (type: `integer`):

How many more days after the date to include (0 = only that day, up to 14). Use 6 for the whole week of a tournament.

## `tours` (type: `array`):

Which circuits to include. Grand Slams appear under ATP and WTA.

## `status` (type: `string`):

Filter matches by state.

## `matchType` (type: `string`):

Doubles rows carry both partners in <code>homePartners</code> / <code>awayPartners</code>.

## `playerName` (type: `string`):

Keep only matches where a player's name contains this text, e.g. <code>Sinner</code>. Works in schedule, live, player and tournament modes.

## `includeOdds` (type: `boolean`):

Pre-match and live match-winner odds (decimal and fractional, opening and current) plus every other market SofaScore shows. One extra request per match.

## `includeStatistics` (type: `boolean`):

Aces, double faults, first-serve percentage, break points, points and games won — for the match and per set — plus head-to-head record and fan votes. Available for live and finished matches; two extra requests per match.

## `includePointByPoint` (type: `boolean`):

Every game with its point sequence, server and game winner. Available for live and finished matches; one extra request per match. Turn on for modelling and trading, off for scores.

## `eventIds` (type: `array`):

SofaScore match ids or match URLs, e.g. <code>16901526</code> or <code>https://www.sofascore.com/tennis/match/francisco-cerundolo-taylor-fritz/RvebsmvNb</code>. Ids come from the <code>eventId</code> field of any match row.

## `playerIds` (type: `array`):

SofaScore player ids or player page URLs, e.g. <code>206570</code> (Jannik Sinner). Use <b>Search</b> mode to find ids by name.

## `tournamentIds` (type: `array`):

SofaScore tournament ids or tournament URLs, e.g. <code>2449</code> (US Open men). Use <b>Search</b> mode to find ids by name.

## `query` (type: `string`):

Player or tournament name, e.g. <code>Alcaraz</code> or <code>Wimbledon</code>. Returns ids you can paste into the fields above.

## `rankingTour` (type: `string`):

Which official ranking to fetch.

## `rankingTop` (type: `integer`):

How many players from the top of each list (up to 500).

## `includeDraw` (type: `boolean`):

One row per draw block — round, both players, seeds, result — so you can rebuild the bracket.

## `maxMatches` (type: `integer`):

Safety cap across all modes.

## `maxMatchesPerPlayer` (type: `integer`):

How many of the player's latest results to return, newest first (0 = profile only).

## `maxMatchesPerTournament` (type: `integer`):

Cap on matches returned for one tournament's current edition, upcoming first then completed.

## `concurrency` (type: `integer`):

How many requests to run at once. Three is gentle; raise it for large date ranges with statistics on.

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

SofaScore answers only residential IPs, so keep <b>Residential</b> proxies on. A whole day of ATP matches is about 250 KB — a fraction of a cent.

## Actor input object example

```json
{
  "mode": "schedule",
  "days": 7,
  "tours": [
    "atp",
    "wta"
  ],
  "status": "any",
  "matchType": "all",
  "includeOdds": false,
  "includeStatistics": false,
  "includePointByPoint": false,
  "rankingTour": "both",
  "rankingTop": 100,
  "includeDraw": false,
  "maxMatches": 500,
  "maxMatchesPerPlayer": 20,
  "maxMatchesPerTournament": 200,
  "concurrency": 3,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `rows` (type: `string`):

One flat row per match (tour, tournament, round, status, start time, both players with country, ranking and seed, set scores, current game, winner, duration, one-sentence summary; optional odds, statistics and point by point), or per ranking entry, player profile, tournament, draw block or search result depending on the mode.

# 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 = {
    "mode": "schedule",
    "days": 7,
    "tours": [
        "atp",
        "wta"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("lergassy/tennis-scores-api").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 = {
    "mode": "schedule",
    "days": 7,
    "tours": [
        "atp",
        "wta",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("lergassy/tennis-scores-api").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 '{
  "mode": "schedule",
  "days": 7,
  "tours": [
    "atp",
    "wta"
  ]
}' |
apify call lergassy/tennis-scores-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,lergassy/tennis-scores-api"
        }
    }
}

```

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/HT7xe5IyUX1Mn59BW/builds/0Cw74vLLmG0u4UE2X/openapi.json