# WTA Tennis Scraper (`lergassy/wta-tennis-scraper`) Actor
Extract official WTA tour data by player name: match history with scores, ranking points and prize money, live ranking tables, player profiles and the tournament calendar. Export scraped data, run the scraper via API, schedule and monitor runs, or integrate with other tools or AI workflows.
- **URL**: https://apify.com/lergassy/wta-tennis-scraper.md
- **Developed by:** [Matvey](https://apify.com/lergassy) (community)
- **Categories:** Sports, News, Automation
- **Stats:** 2 total users, 1 monthly users, 100.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
**WTA Tennis Scraper** extracts official WTA tour data — match histories, ranking tables, player profiles and the tournament calendar — straight from the women's tour's own public data service. You look players up **by name**, not by numeric ID, and every row comes back flat and ready for a spreadsheet, a database or an AI agent. No login, no API key, no official API needed.
Most tennis scrapers read a third-party score aggregator. This one reads what the tour itself publishes, so each match row carries the things aggregators do not have: the ranking points earned, the prize money won, the seeding, the entry type, the draw size and the official tournament tier.
### What data can WTA Tennis Scraper extract?
Four datasets, chosen with the **What to collect** input.
| Mode | One row is | Typical use |
|---|---|---|
| 🎾 Player matches | One match a player played | Form guides, head-to-head research, model training data |
| 🏆 Rankings | One player in the current ranking table | Ranking snapshots, movement tracking |
| 👤 Players | One player profile | Building a player reference table |
| 📅 Tournaments | One tournament edition | Calendars, prize-money analysis, surface breakdowns |
#### Match fields
| Field | Example |
|---|---|
| `date` | 2026-08-13 |
| `tournamentName` / `tournamentTitle` | CINCINNATI / Cincinnati Open |
| `level` | Grand Slam, WTA 1000, WTA 500, WTA 250, WTA 125, ITF |
| `surface` / `indoorOutdoor` | HARD / outdoor |
| `round` | F, SF, QF, R16, R32, R64, R128, Q |
| `playerName` / `playerRank` / `playerSeed` / `playerEntry` | Aryna Sabalenka / 1 / 1 / Q |
| `opponentName` / `opponentRank` / `opponentSeed` | Rebeka Masarova / 112 / — |
| `score` | 6-2 7-6(6) — as published, from the winner's side |
| `won` / `winnerName` / `loserName` | true / Aryna Sabalenka / Rebeka Masarova |
| `outcome` | completed, retired, walkover, defaulted, bye |
| `rankingPoints` | 195 |
| `prizeWon` / `tournamentPrizeMoney` | 59100 / 1064510 |
| `discipline` / `partnerName` | singles or doubles, with the partner on doubles rows |
#### Ranking fields
`rank`, `points`, `tournamentsPlayed`, `movement` (places gained or lost since the previous table), `rankedAt` (the date the table was published), plus the full player profile.
#### Tournament fields
`tournamentName`, `title`, `year`, `level`, `startDate`, `endDate`, `surface`, `indoorOutdoor`, `city`, `country`, `singlesDrawSize`, `doublesDrawSize`, `prizeMoney`, `prizeMoneyCurrency`.
### How to scrape WTA tennis data
1. Click **Try for free** and open the input form.
2. Leave **What to collect** on *Player matches*.
3. Type one or more players into **Player names** — partial names work, `swiatek` finds Iga Swiatek.
4. Set **Maximum rows** to something small like 50 for the first run.
5. Click **Start**, then open the **Output** tab and export to CSV, Excel or JSON.
There is nothing else to configure. No proxy, no cookies, no account.
### ⬇️ Input
```json
{
"mode": "player-matches",
"playerNames": ["Aryna Sabalenka", "Iga Swiatek"],
"dateFrom": "2026-01-01",
"dateTo": "2026-08-31",
"maxItems": 100,
"newestFirst": true
}
```
#### Matches inside a date window
**Played from** and **Played until** keep only the matches played in that window, in
`YYYY-MM-DD`. Either one works on its own: set only **Played from** for "everything since
the Australian Open", only **Played until** for form before a given tournament. The window
is applied to each player separately, so a request for two players returns both of their
seasons, cut the same way. A season number in **Season** still works and is faster when a
whole calendar year is what you want.
#### Searching by name instead of ID
Other tennis Actors ask for a numeric player or tournament ID and leave you to find it yourself. Here you type the name. The Actor resolves it against the tour's player index (36,000+ players, current and historical) and logs which player it picked when a name is ambiguous, so you can tighten the spelling if needed. IDs still work if you already have them — put them in **Player IDs**.
#### Filtering one season
```json
{
"mode": "player-matches",
"playerNames": ["Coco Gauff"],
"year": 2026,
"maxItems": 200
}
```
#### Ranking table
```json
{ "mode": "rankings", "rankingType": "singles", "maxItems": 100 }
```
### ⬆️ Output
One flat row per match. No nested objects, so CSV and Google Sheets exports stay readable.
```json
{
"type": "match",
"date": "2026-08-13",
"tournamentName": "CINCINNATI",
"tournamentTitle": "Cincinnati Open - Cincinnati, OH, USA",
"level": "WTA 1000",
"surface": "HARD",
"indoorOutdoor": "outdoor",
"round": "R32",
"discipline": "singles",
"playerName": "Aryna Sabalenka",
"playerCountry": "BLR",
"playerRank": 1,
"playerSeed": 1,
"opponentName": "Xinyu Wang",
"opponentCountry": "CHN",
"opponentRank": 36,
"score": "6-1 6-3",
"won": true,
"winnerName": "Aryna Sabalenka",
"loserName": "Xinyu Wang",
"outcome": "completed",
"rankingPoints": 120,
"prizeWon": 81752,
"tournamentPrizeMoney": 7433076
}
```
The tour publishes a score from the winner's side, so `score` alone does not say who won. The row states it outright: `won` is about the player you asked for, and `winnerName` and `loserName` name both sides.
### How much does it cost to scrape WTA data?
Pay per row, with no charge for a run that returns nothing.
| Event | Price per 1,000 |
|---|---|
| Match | $4.00 |
| Ranking row | $3.00 |
| Player profile | $2.00 |
| Tournament | $2.00 |
The Apify free plan includes $5 of monthly usage, which is roughly **1,200 match rows a month at no cost** — enough to pull the full recent history of a dozen players. Paid Apify plans get tiered discounts down to $2.80 per 1,000 matches.
This Actor talks to a public JSON service over plain HTTP. It runs no browser and needs no residential proxies, which is why it is priced below scrapers that do.
### Use cases for WTA data
#### Betting and prediction models
Ranking at the time of the match, seeding, surface, round and result in one row — the feature set a match-outcome model actually needs, with a career of history behind it.
#### Sports media and content
Head-to-head records, career win-loss on a surface, prize money earned in a season. Pull the rows, publish the story.
#### Player and agency analytics
Ranking points and prize money per tournament, entry type (qualifier, wild card, lucky loser), and how far a player went in each draw.
#### AI agents and RAG pipelines
Flat, literal field names and a small input schema mean an agent can call this Actor correctly without reading the docs. It works through the Apify MCP server like any other tool.
### Integrations
Run it from the Apify API, the Python or JavaScript client, the CLI, or a scheduled task. Connect it to n8n, Make, Zapier, Google Sheets or Slack through the Apify integrations, or wire it to your own service with a webhook that fires when a run finishes.
```python
from apify_client import ApifyClient
client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('lergassy/wta-tennis-scraper').call(run_input={
'mode': 'player-matches',
'playerNames': ['Iga Swiatek'],
'maxItems': 50,
})
for row in client.dataset(run['defaultDatasetId']).iterate_items():
print(row['date'], row['tournamentName'], row['score'])
```
### Error rows
When a player name matches nothing, or the data service fails on one request, the Actor writes an `error` row instead of stopping the run:
```json
{ "type": "error", "scope": "playerSearch", "query": "Zzzz Nonexistent", "error": "no WTA player matched this name" }
```
Error rows are **never charged**. The rest of the run continues, so one bad spelling in a list of forty players does not cost you the run.
### ❓ FAQ
#### Is it legal to scrape WTA tennis data?
This Actor reads the public data service behind wtatennis.com. That site's `robots.txt` allows all crawlers on all paths, the data is published for public viewing, and match results are facts rather than creative work. No login is used and no personal data beyond what the tour publishes about professional players — name, country, date of birth, results — is collected. If your use case is commercial and unusual, check with your own lawyer.
#### How fresh is the data?
Rankings update weekly, on the tour's own schedule, and the `rankedAt` field tells you exactly which table you got. Match results lag the live schedule: a tournament that finished in the last week or two may not have landed yet. **This Actor is for history and analysis, not live scores.** If you need a match in progress, you need a live-scoring feed, not this.
#### Does it cover ATP or men's tennis?
No. This is the WTA tour: women's singles and doubles, including WTA 125 and the ITF events that count toward WTA rankings. Men's tennis is a separate source with a separate access story.
#### How far back does the history go?
The tournament calendar reaches back to 1960. Match histories go back to the start of each player's professional record — 988 matches for Aryna Sabalenka, 1,221 for Venus Williams, all reachable in one run.
#### Can I use it with the Apify API?
Yes. Every Actor on Apify is an API endpoint. See the **API** tab for ready-made calls in curl, Python, JavaScript and the CLI.
#### Can I use it through an MCP server?
Yes. It is exposed through the Apify MCP server, so Claude, ChatGPT, Cursor and other MCP clients can call it as a tool. The input schema is small and literal on purpose.
#### Is one row one match?
Yes — one row per match, per player you asked for. If you request two players who met each other, that match appears twice, once from each player's point of view.
#### Why is a name matched to the wrong player?
Common surnames can collide. The run log prints every alternative it found, so you can switch to the full name or drop the exact ID into **Player IDs**.
### Your feedback
Found a missing field, a wrong mapping, or a player the search cannot find? Open an issue on the **Issues** tab or leave a review — both get answered.
### You might also like
| Actor | What it does |
|---|---|
| [Agoda Reviews Scraper](https://apify.com/lergassy/agoda-reviews-scraper) | Hotel reviews and ratings from Agoda |
| [Trip.com Scraper](https://apify.com/lergassy/tripcom-scraper) | Hotels, prices and reviews from Trip.com |
| [Google Flights Scraper](https://apify.com/lergassy/google-flights-scraper) | Flight itineraries, prices and booking links |
| [Trustpilot Reviews API](https://apify.com/lergassy/trustpilot-reviews-api) | Company reviews and ratings from Trustpilot |
| [Document Text Extractor](https://apify.com/lergassy/document-text-extractor) | Text and OCR from PDFs and documents |
# Actor input Schema
## `mode` (type: `string`):
Pick the dataset you want. Player matches returns one row per match a player has played, Rankings the current WTA ranking table, Players profile rows, Tournaments the tour calendar with prize money.
## `playerNames` (type: `array`):
Type players by name — no numeric IDs to look up first. Partial names work: swiatek finds Iga Swiatek. Used by the Player matches and Players modes.
## `playerIds` (type: `array`):
Optional WTA player IDs, if you already have them from a previous run (for example 320760). Combined with any names above.
## `maxItems` (type: `integer`):
Total rows to return across all players. Keep it low for a first test run — you are charged per row.
## `newestFirst` (type: `boolean`):
Return the latest matches and tournaments instead of the oldest. Turn this off to start from a player's first professional match.
## `year` (type: `integer`):
Limit match rows to a single season, for example 2026. Leave empty for a player's whole career.
## `dateFrom` (type: `string`):
Keep only matches played on or after this date, format YYYY-MM-DD. Leave empty for no lower bound.
## `dateTo` (type: `string`):
Keep only matches played on or before this date, format YYYY-MM-DD. Works with or without Played from.
## `rankingType` (type: `string`):
Singles or doubles ranking. Only used by the Rankings mode.
## Actor input object example
```json
{
"mode": "player-matches",
"playerNames": [
"Aryna Sabalenka",
"Iga Swiatek"
],
"playerIds": [],
"maxItems": 100,
"newestFirst": true,
"rankingType": "singles"
}
```
# Actor output Schema
## `matches` (type: `string`):
Match, ranking, player and tournament rows collected in this run.
# 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 '' with your token
const client = new ApifyClient({
token: '',
});
// Prepare Actor input
const input = {
"playerNames": [
"Aryna Sabalenka",
"Iga Swiatek"
]
};
// Run the Actor and wait for it to finish
const run = await client.actor("lergassy/wta-tennis-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 '' with your token.
client = ApifyClient("")
# Prepare the Actor input
run_input = { "playerNames": [
"Aryna Sabalenka",
"Iga Swiatek",
] }
# Run the Actor and wait for it to finish
run = client.actor("lergassy/wta-tennis-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 '{
"playerNames": [
"Aryna Sabalenka",
"Iga Swiatek"
]
}' |
apify call lergassy/wta-tennis-scraper --silent --output-dataset
```
## MCP server setup
```json
{
"mcpServers": {
"apify": {
"type": "http",
"url": "https://mcp.apify.com/?tools=fetch-actor-details,lergassy/wta-tennis-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 ` 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/uDcgZmpcqRZoLRlpM/builds/B4Cv5ZphwFSmXQWNx/openapi.json