# Tennis Abstract Scraper: ATP & WTA Match Stats (`fayoussef/tennis-abstract-scraper`) Actor

Scrape every ATP and WTA player's full career match log from Tennis Abstract: score, opponent, ranks, surface, level, aces, double faults, first and second serve won %, break points and dominance ratio. Pick players by name or the top N of the ATP or WTA ranking. Export to JSON, CSV or Excel.

- **URL**: https://apify.com/fayoussef/tennis-abstract-scraper.md
- **Developed by:** [Youssef Farhan](https://apify.com/fayoussef) (community)
- **Categories:** Developer tools, MCP servers
- **Features:** Limited permissions
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.40 / 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?

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

## Tennis Abstract Scraper: ATP & WTA Match Stats, Serve & Return Data

> **What is the Tennis Abstract Scraper?** It is an Apify Actor that exports every ATP and WTA player's full career match log from [Tennis Abstract](https://www.tennisabstract.com), the tennis statistics site, with 60+ fields per match: score, opponent, ranks, tournament level, surface, aces, double faults, first and second serve points won, break points and dominance ratio. Output is JSON, CSV or Excel.

**Scrape ATP and WTA match stats at scale.** Type a player's name (or paste their Tennis Abstract page), or ask for the top 100 of the current ATP or WTA ranking, and get one row per match for their whole career: Grand Slams, Masters and WTA 1000, ATP 250 and 500, WTA Premier and International (and the old WTA Tiers), Tour Finals, Davis Cup, Billie Jean King Cup, Olympics, Challengers, WTA 125 and ITF events. Filter by date, level and surface. One player's whole career comes back in a few seconds; the top 50 ATP players (about 28,000 matches) take about four minutes, the top 10 WTA players about one minute.

Built for **tennis bettors and modellers** who need serve and return stats per match, **data scientists** building Elo or prediction models, **tennis writers and podcasters** checking form and head-to-head numbers, and **fantasy and analytics apps** that need a clean match feed. Runs on Apify, so you get the API, scheduling and integrations for free.

### Key features at a glance

- **Full ATP and WTA careers**: every match Tennis Abstract has for the player, back to their first ITF event. Retired players (Federer, Nadal, Serena Williams) work too.
- **Serve and return stats per match**: aces, double faults, first serve in, first and second serve points won, service games, break points saved and converted, for both players.
- **Ready-made percentages**: ace %, double fault %, first serve in %, 1st and 2nd serve won %, serve and return points won %, and dominance ratio, next to the raw counts.
- **Context for every match**: date, tournament, level, surface, round, best of 3 or 5, minutes played, both players' ranks and seeds, wildcard and qualifier entries.
- **Opponent details**: country, hand, backhand, height and birthdate.
- **Top N of the ATP or WTA ranking** in one setting, so a weekly refresh of the top 100 is one input.
- **Filters**: date range, tournament level, surface, and "only matches with serve stats".
- **Fast and light**: one request per player, no browser.

### What data does the Tennis Abstract scraper extract?

| Field | Example | Description |
|---|---|---|
| `tour` | ATP | ATP or WTA |
| `player` | Jannik Sinner | The player whose match log this is |
| `date` | 2026-06-29 | Tournament start date |
| `tournament`, `level`, `surface` | Wimbledon, Grand Slam, Grass | Event, level (Grand Slam, Masters 1000, ATP Tour, WTA 1000 (Premier Mandatory), WTA Premier, WTA International, WTA Tier I to V, Tour Finals, Davis Cup, Billie Jean King Cup, Olympics, Challenger, WTA 125, ITF) and surface; `level_code` keeps the site's own code |
| `round`, `best_of`, `minutes` | F, 5, 226 | Round, sets format and match length |
| `result` | W | W or L, from the player's side |
| `score` | 6-7(7) 7-6(2) 6-3 6-4 | Winner's games first, as on Tennis Abstract (a loss reads from the opponent's side) |
| `player_rank`, `player_seed`, `player_entry` | 1, 1, null | Ranking and seed at the time; entry is WC, Q, LL or Alt |
| `opponent`, `opponent_rank`, `opponent_seed` | Alexander Zverev, 3, 2 | Opponent and their ranking at the time |
| `opponent_country`, `opponent_hand`, `opponent_backhand`, `opponent_height_cm`, `opponent_birthdate` | GER, R, two-handed, 198, 1997-04-20 | Opponent details |
| `has_stats` | true | Whether the match has point-level stats (most tour matches do, many ITF matches do not) |
| `dominance_ratio` | 1.24 | Return points won % divided by serve points lost % |
| `serve_points_won_pct`, `return_points_won_pct` | 75.0, 30.9 | Share of serve and return points won |
| `ace_pct`, `double_fault_pct` | 11.0, 1.5 | Per serve point |
| `first_serve_in_pct`, `first_serve_won_pct`, `second_serve_won_pct` | 64.0, 80.5, 65.3 | Serve breakdown |
| `break_points_saved`, `break_points_faced` | 1, 1 | On the player's serve |
| `break_points_converted`, `break_points_chances` | 2, 5 | On the opponent's serve |
| `opponent_ace_pct`, `opponent_first_serve_won_pct`, `opponent_second_serve_won_pct` | 12.2, 72.4, 58.8 | The opponent's serve |
| `aces`, `double_faults`, `serve_points`, `first_serves_in`, `first_serve_points_won`, `second_serve_points_won`, `service_games` | 15, 2, 136, 87, 70, 32, 22 | Raw counts behind the percentages |
| `opponent_aces` ... `opponent_service_games` | 17 ... 21 | The same raw counts for the opponent |
| `match_id` | 2026-540-603 | Tennis Abstract match id |
| `player_country`, `player_hand`, `player_height_cm`, `player_birthdate` | ITA, R, 191, 2001-08-16 | Player details |
| `player_current_rank`, `player_peak_rank`, `player_elo_rating` | 2, 1, 2297 | As shown on the player's page today |
| `player_url` | https://www.tennisabstract.com/cgi-bin/player.cgi?p=JannikSinner | Player page |

Percentages are `null`, never 0, when a match has no stats.

#### Sample output

```json
{
  "player": "Jannik Sinner",
  "date": "2026-06-29",
  "tournament": "Wimbledon",
  "level": "Grand Slam",
  "surface": "Grass",
  "round": "F",
  "result": "W",
  "score": "6-7(7) 7-6(2) 6-3 6-4",
  "best_of": 5,
  "minutes": 226,
  "player_rank": 1,
  "opponent": "Alexander Zverev",
  "opponent_rank": 3,
  "has_stats": true,
  "dominance_ratio": 1.24,
  "serve_points_won_pct": 75.0,
  "return_points_won_pct": 30.9,
  "ace_pct": 11.0,
  "double_fault_pct": 1.5,
  "first_serve_in_pct": 64.0,
  "first_serve_won_pct": 80.5,
  "second_serve_won_pct": 65.3,
  "break_points_saved": 1,
  "break_points_faced": 1,
  "break_points_converted": 2,
  "break_points_chances": 5,
  "match_id": "2026-540-603",
  "player_url": "https://www.tennisabstract.com/cgi-bin/player.cgi?p=JannikSinner"
}
```

### How to scrape Tennis Abstract match stats

1. Open the Actor and type one or more player names in **Players**, for example `Jannik Sinner`, or set **Top ranked players** to `100`.
2. Optionally narrow it down with **Matches from / to**, **Tournament level** and **Surface**.
3. Click **Start**. Download the matches as JSON, CSV or Excel, or read them through the API.

### Input

| Field | Example | Description |
|---|---|---|
| `players` | `["Jannik Sinner", "Roger Federer"]` | ATP player names or Tennis Abstract player page URLs (a WTA page URL works here too) |
| `wta_players` | `["Iga Swiatek"]` | WTA player names or Tennis Abstract WTA page URLs |
| `top_ranked`, `top_ranked_wta` | `100` | Also add the top N of the current ATP or WTA ranking (up to 500 each) |
| `date_from`, `date_to` | `2025-01-01` | Only matches in this date range |
| `levels` | `["G", "M"]` | G Grand Slam, M Masters 1000 / WTA 1000 (and WTA Tier I), F Tour Finals, A tour level (ATP 250/500, WTA Premier, International, Tiers II to V), O Olympics, D Davis Cup / Billie Jean King Cup, C Challenger / WTA 125, S ITF |
| `surfaces` | `["Hard", "Clay"]` | Hard, Clay, Grass, Carpet |
| `only_with_stats` | `false` | Skip matches without serve stats |
| `max_items` | `1000` | Stop after this many matches |

```json
{
  "top_ranked": 100,
  "date_from": "2025-01-01",
  "levels": ["G", "M", "A"],
  "only_with_stats": true
}
```

Names are matched the way Tennis Abstract spells them, without accents: `Felix Auger-Aliassime`, `Botic van de Zandschulp` and `Alex de Minaur` all work. If a name is not found, the run log says so and moves on; pasting the player's page URL always works.

### Who uses a Tennis Abstract scraper?

- **Tennis bettors and tipsters**: recent serve and return form, surface splits and dominance ratio before a match.
- **Modellers and data scientists**: a clean per-match dataset for Elo, point-win or betting models.
- **Writers, podcasters and broadcasters**: quick numbers on a player's season or career.
- **Fantasy and analytics apps**: a scheduled match feed for the top of the ranking.

### Pricing

This Actor is **pay per result**: you pay for each match saved to the dataset, plus a tiny per-run start event. Matches removed by your filters are never charged. **The current rate is shown on this Actor's Store page.**

On the Apify Free plan, each run returns up to 100 matches, so you can check the data before subscribing to an [Apify plan](https://apify.com/pricing?fpr=youssef).

### Tips

- **Weekly refresh**: schedule a run with `top_ranked` and `date_from` set to last week to keep a betting or model dataset current.
- **Surface models**: run once per surface, or filter afterwards on `surface`.
- **Score from the player's side**: when `result` is `L`, the score reads from the opponent's side, as on the site.

### Frequently asked questions (FAQ)

#### Does it cover WTA players?

Yes. Put WTA players in **WTA players** (or set **Top ranked WTA players**). Every row has a `tour` field, so one run can mix both tours.

#### How far back does the data go?

As far as Tennis Abstract has the player's matches, usually their whole career. Federer's log starts in 1996, Serena Williams' in 1995, and older seasons have fewer point-level stats.

#### Why do some matches have no stats?

Tennis Abstract only has point-level stats for matches where they were published, which covers nearly all tour-level matches and fewer Challenger and ITF ones. Those rows keep the score and context, with the stats set to `null`. Turn on **Only matches with serve stats** to skip them.

#### How fast is it?

Tennis Abstract is run by one person, so the Actor fetches one player every few seconds to stay polite. A single player takes a few seconds; the top 100 takes about eight minutes.

#### Is it legal to scrape Tennis Abstract?

The Actor reads only public, no-login player data that Tennis Abstract shows to every visitor, at a slow pace, and no personal data beyond what it publishes about professional players. Check that your own use fits your local rules.

### Use via API or MCP

Run it from any language through the [Apify API](https://docs.apify.com/api/v2), or from AI agents through the [Apify MCP server](https://mcp.apify.com). Results land in a dataset you can download as JSON, CSV or Excel.

### Need a custom scraper?

Need head-to-head reports, doubles or another sports site? [Contact me through my Apify profile](https://apify.com/fayoussef). Bugs go to the [Issues tab](https://apify.com/fayoussef/tennis-abstract-scraper/issues/open).

# Actor input Schema

## `players` (type: `array`):

One ATP (men's) player per line: a name (`Jannik Sinner`, `Felix Auger-Aliassime`, `Roger Federer`) or a Tennis Abstract player page (`https://www.tennisabstract.com/cgi-bin/player.cgi?p=JannikSinner`). Retired players work too. Each player returns their whole career.

## `wta_players` (type: `array`):

One WTA (women's) player per line: a name (`Iga Swiatek`, `Aryna Sabalenka`, `Serena Williams`) or a Tennis Abstract WTA page (`https://www.tennisabstract.com/cgi-bin/wplayer.cgi?p=IgaSwiatek`). Each player returns their whole career.

## `top_ranked` (type: `integer`):

Also add the top N players of the current ATP ranking (for example `100`). Leave empty or 0 to skip.

## `top_ranked_wta` (type: `integer`):

Also add the top N players of the current WTA ranking (for example `100`). Leave empty or 0 to skip.

## `date_from` (type: `string`):

Only matches on or after this date (tournament start date). Leave empty for the whole career.

## `date_to` (type: `string`):

Only matches on or before this date. Leave empty for up to today.

## `levels` (type: `array`):

Only these kinds of events. Leave empty for all.

## `surfaces` (type: `array`):

Only matches on these surfaces. Leave empty for all.

## `only_with_stats` (type: `boolean`):

Skip matches that have no point-level stats (mostly ITF and some Challenger matches). Tour-level matches nearly always have them.

## `max_items` (type: `integer`):

Stop after this many matches in total. Leave empty to get every match that passes the filters.

## Actor input object example

```json
{
  "players": [
    "Jannik Sinner",
    "Carlos Alcaraz"
  ],
  "wta_players": [
    "Iga Swiatek"
  ],
  "only_with_stats": false,
  "max_items": 100
}
```

# Actor output Schema

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

One record per ATP or WTA match: date, tournament, surface, round, score, opponent, ranks and serve and return stats.

# 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 = {
    "players": [
        "Jannik Sinner",
        "Carlos Alcaraz"
    ],
    "wta_players": [
        "Iga Swiatek"
    ],
    "max_items": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("fayoussef/tennis-abstract-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 = {
    "players": [
        "Jannik Sinner",
        "Carlos Alcaraz",
    ],
    "wta_players": ["Iga Swiatek"],
    "max_items": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("fayoussef/tennis-abstract-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 '{
  "players": [
    "Jannik Sinner",
    "Carlos Alcaraz"
  ],
  "wta_players": [
    "Iga Swiatek"
  ],
  "max_items": 100
}' |
apify call fayoussef/tennis-abstract-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,fayoussef/tennis-abstract-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/Tva3oNwFtyEATIsue/builds/9cS0t35EgCm31SISu/openapi.json
