# Tennis Abstract Player Match Scraper & API (`parsebird/tennis-abstract-match-scraper`) Actor Scrape ATP and WTA match histories from Tennis Abstract by player. Extract scores, surfaces, rounds, rankings, and serve/return stats like ace rate, dominance ratio, and break points saved. - **URL**: https://apify.com/parsebird/tennis-abstract-match-scraper.md - **Developed by:** [ParseBird](https://apify.com/parsebird) (community) - **Categories:** News, Automation, Integrations - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks - **User rating**: No ratings yet ## Pricing from $4.99 / 1,000 match scrapeds 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/platform/actors/running/actors-in-store#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 Abstract Player Match Scraper & API Scrape ATP and WTA match histories from [Tennis Abstract](https://www.tennisabstract.com/) by player — full career results with scores, surfaces, rankings, and the serve/return stats (ace rate, dominance ratio, break points saved) that make Tennis Abstract the go-to source for tennis analytics.
Pull a player's entire match log — hundreds to over a thousand matches for long careers — normalized into one schema with rankings, scores, and serve/return stats computed directly from published point counts.
##### Copy to your AI assistant Copy this block into ChatGPT, Claude, Cursor, or any LLM to start using this actor. ``` parsebird/tennis-abstract-match-scraper on Apify. Call: ApifyClient("TOKEN").actor("parsebird/tennis-abstract-match-scraper").call(run_input={...}), then client.dataset(run["defaultDatasetId"]).list_items().items for results. Key inputs: playerSlugs (string array, the p= parameter from a Tennis Abstract player URL, e.g. "NovakDjokovic", "IgaSwiatek"), startUrls (request list of Tennis Abstract player URLs, alternative to playerSlugs), maxItems (integer, default 100, 1-10000), surfaces (array, any of "Hard"/"Clay"/"Grass"/"Carpet", default all), fromDate/toDate (ISO "YYYY-MM-DD", inclusive). Output fields: matchId, playerSlug, playerName, playerUrl, date, tournament, tournamentUrl, surface, round, playerRank, opponent, opponentSlug, opponentUrl, opponentRank, opponentCountry, outcome ("win"/"loss"), score, dominanceRatio, aceRate, doubleFaultRate, firstServeIn, firstServeWon, secondServeWon, breakPointsSaved, duration, sourceUrl, scrapedAt. Full actor spec: fetch build via GET https://api.apify.com/v2/acts/parsebird~tennis-abstract-match-scraper (Bearer TOKEN). Get token: https://console.apify.com/account/integrations ``` ### What does Tennis Abstract Player Match Scraper do? This Actor scrapes [tennisabstract.com](https://www.tennisabstract.com/), the tennis analytics site run by Jeff Sackmann, pulling a player's full ATP or WTA match history and normalizing it into one consistent schema — regardless of which internal data source Tennis Abstract happens to serve it from. - 🎾 **Full career coverage** — hundreds to 1,500+ matches for long careers, not just recent results - 📊 **Real serve/return stats** — ace rate, double fault rate, first/second serve won, and dominance ratio, computed directly from the published point counts (not scraped from a rendered percentage that can round differently) - 🏆 **Match context** — tournament, surface, round, both players' rankings at the time, score (including RET/W-O markers), and match duration - 🔀 **ATP and WTA in one actor** — works identically for men's and women's players from a single input - 🎯 **Filter by surface and date** — narrow to a specific era or surface (e.g. clay-court results since 2024) without post-processing - ⏱️ **Scheduling** — run this Actor weekly via Apify Scheduler to keep a player's match log current as new results are published - 🔌 **API access** — trigger runs and pull results programmatically via the Apify API or client libraries - 📊 **Flexible export** — download results as JSON, CSV, or Excel, or query them via API ### What data can you extract? | Field | Description | |-------|-------------| | `date` / `tournament` / `surface` / `round` | Match context | | `playerRank` / `opponentRank` | Rankings at the time of the tournament | | `opponent` / `opponentSlug` / `opponentUrl` / `opponentCountry` | Opponent identity | | `outcome` / `score` | `"win"`/`"loss"` and the published score, including `RET`/`W/O` markers | | `dominanceRatio` | Return points won % ÷ serve points lost % — Tennis Abstract's headline stat for match control | | `aceRate` / `doubleFaultRate` / `firstServeIn` / `firstServeWon` / `secondServeWon` | Serve stats, each expressed 0–1 | | `breakPointsSaved` | `"saved/faced"` text, e.g. `"10/13"` | | `duration` | Match length, e.g. `"2:20"` | | `sourceUrl` | The exact Tennis Abstract data source used for that player | Detailed serve/return stats are only published for matches Tennis Abstract charted in depth — when they're not available, those fields are `null` while match context (date, score, opponent, outcome) is still returned. ### Input parameters | Parameter | Type | Default | Description | |-----------|------|---------|-------------| | `playerSlugs` | string array | none | Player identifiers from the page `p=` parameter, e.g. `NovakDjokovic` | | `startUrls` | request list | none | Public Tennis Abstract player or classic-player URLs | | `maxItems` | integer | `100` | Global row limit from 1 to 10,000 | | `surfaces` | string array | all | Any of `Hard`, `Clay`, `Grass`, or `Carpet` | | `fromDate` | string | none | Inclusive earliest match date, `YYYY-MM-DD` | | `toDate` | string | none | Inclusive latest match date, `YYYY-MM-DD` | | `proxyConfiguration` | object | direct | Optional Apify or custom proxy settings | ### Output example ```json { "matchId": "8b315f1b0539ee246e6b5aaca9d70c9bc5ec9acd", "playerSlug": "NovakDjokovic", "playerName": "Novak Djokovic", "playerUrl": "https://www.tennisabstract.com/cgi-bin/player.cgi?p=NovakDjokovic", "date": "2026-06-29", "tournament": "Wimbledon", "tournamentUrl": "https://www.tennisabstract.com/cgi-bin/tourney.cgi?t=2026-540/Wimbledon", "surface": "Grass", "round": "SF", "playerRank": 8, "opponent": "Jannik Sinner", "opponentSlug": "JannikSinner", "opponentUrl": "https://www.tennisabstract.com/cgi-bin/player.cgi?p=JannikSinner", "opponentRank": 1, "opponentCountry": "ITA", "outcome": "loss", "score": "6-4 6-4 6-4", "dominanceRatio": 0.551, "aceRate": 0.076, "doubleFaultRate": 0.029, "firstServeIn": 0.638, "firstServeWon": 0.761, "secondServeWon": 0.342, "breakPointsSaved": "10/13", "duration": "2:20", "sourceUrl": "https://www.tennisabstract.com/cgi-bin/player-classic.cgi?p=NovakDjokovic", "scrapedAt": "2026-07-28T06:00:00.000Z" } ``` Download results in **JSON, CSV, or Excel** directly from the Apify Console, or pull them programmatically via the API. ### Use cases - **Tennis analytics and modeling** — build match-outcome or serve-performance models from real point-count-derived stats - **Scouting and opponent prep** — pull a player's full surface-specific record before a matchup - **Content and media** — power head-to-head graphics, career trend charts, or surface breakdowns - **Betting research** — analyze dominance ratio and serve trends across surfaces and date ranges - **Historical research** — full career logs for long-retired and active players alike ### How it works 1. Go to the [Tennis Abstract Player Match Scraper](https://apify.com/parsebird/tennis-abstract-match-scraper) page on Apify Store 2. Click **Try for free** — new users get a free trial to test the Actor before paying 3. Enter one or more **player slugs** (e.g. `NovakDjokovic`, `IgaSwiatek`) or paste **player URLs** into `startUrls` 4. Optionally filter by **surface** and **date range**, and set `maxItems` to cap the total rows 5. Click **Start** — the Actor fetches the player's full match log and normalizes every row 6. When the run finishes, download your data as **JSON, CSV, or Excel**, or fetch it via the API ### Use with the Apify API **Python** ```python from apify_client import ApifyClient client = ApifyClient("YOUR_API_TOKEN") run = client.actor("parsebird/tennis-abstract-match-scraper").call(run_input={ "playerSlugs": ["IgaSwiatek", "ArynaSabalenka"], "surfaces": ["Clay"], "fromDate": "2024-01-01", "maxItems": 200, }) for item in client.dataset(run["defaultDatasetId"]).iterate_items(): print(f"{item['date']} {item['tournament']} {item['round']} - {item['playerName']} vs {item['opponent']}: {item['outcome']} {item['score']}") ``` **JavaScript** ```javascript import { ApifyClient } from 'apify-client'; const client = new ApifyClient({ token: 'YOUR_API_TOKEN' }); const run = await client.actor('parsebird/tennis-abstract-match-scraper').call({ playerSlugs: ['IgaSwiatek', 'ArynaSabalenka'], surfaces: ['Clay'], fromDate: '2024-01-01', maxItems: 200, }); const { items } = await client.dataset(run.defaultDatasetId).listItems(); items.forEach((item) => { console.log(`${item.date} ${item.tournament} ${item.round} - ${item.playerName} vs ${item.opponent}: ${item.outcome} ${item.score}`); }); ``` See the [Apify API documentation](https://docs.apify.com/api/v2) for full reference, or the Actor's **API** tab for ready-to-run request snippets in more languages. ### How much does it cost to run? This Actor uses **Pay-per-event** pricing — you only pay for match rows actually returned, with no separate platform rental fee. | Plan | Price per event | Price per 1,000 | |------|-----------------|-----------------| | Free | $0.00699 | $6.99 | | Bronze | $0.00599 | $5.99 | | Silver | $0.00599 | $5.99 | | Gold | $0.00499 | $4.99 | One `match-scraped` event is charged for each match row successfully normalized and pushed to the dataset. A full career pull for a long-tenured player (~1,000 matches) costs about $7.00 on the Free plan or $5.00 on Gold. Start with a low `maxItems` on the free trial to preview a player's data before pulling their full history. ### FAQ **How do I scrape a player's full match history, not just recent results?** Leave `maxItems` at a high value (up to 10,000) and don't set `fromDate` — the Actor pulls the player's complete logged match history by default, not just their most recent matches. **Does this work for both men's and women's players?** Yes, from the same input. Tennis Abstract serves ATP and WTA data through different internal endpoints with different quirks; this Actor detects which one a given player needs and normalizes the result identically either way. **Why is `tournamentUrl` sometimes null?** Tennis Abstract's tournament-link format is only reliably reconstructable from the data source used for most men's matches. Rather than guess and risk a broken link, `tournamentUrl` is left `null` when we can't construct it with confidence — every other match field is unaffected. **Why are some serve/return stats null?** Tennis Abstract only publishes detailed serve/return stats for matches it charted in depth. Every match includes date, score, opponent, and outcome regardless; the rate stats populate when the source has them. **Can I filter by surface or date range?** Yes. Set `surfaces` to any of `Hard`, `Clay`, `Grass`, `Carpet`, and/or `fromDate`/`toDate` to restrict to a specific era. **Can I schedule recurring runs?** Yes. Use Apify's [Scheduler](https://docs.apify.com/platform/schedules) to run this Actor weekly and pick up new matches as a player's season progresses. **Is it legal to scrape Tennis Abstract?** Tennis Abstract publishes match data for public viewing without a login or paywall. You're responsible for complying with the site's terms of use for your specific use case. See Apify's [blog post on the legality of web scraping](https://blog.apify.com/is-web-scraping-legal/) for general background. **Can I access results via API?** Yes. Every run's dataset is available through the [Apify API](https://docs.apify.com/api/v2) and client libraries (Python, JavaScript) — see the Actor's **API** tab for ready-made snippets. **Something not working?** Open an issue on the Actor's **Issues** tab in Apify Console — the ParseBird team monitors it directly. ### Related Actors Other data-extraction Actors from ParseBird: - [Polymarket Market Scraper](https://apify.com/parsebird/polymarket-market-scraper) — structured prediction-market data, including sports markets - [DexScreener Crypto Scraper](https://apify.com/parsebird/dexscreener-crypto-scraper) — real-time token and market data - [Website Contact Finder](https://apify.com/parsebird/website-contact-finder) — extract emails, phone numbers, and social links from any website # Actor input Schema ## `playerSlugs` (type: `array`): Tennis Abstract player identifiers — the p= parameter from a player URL, e.g. NovakDjokovic, IgaSwiatek, ArynaSabalenka. ## `startUrls` (type: `array`): Public Tennis Abstract player URLs (player.cgi), e.g. https://www.tennisabstract.com/cgi-bin/player.cgi?p=NovakDjokovic. The player slug is read from the p= parameter. ## `maxItems` (type: `integer`): Global row limit across all requested players, from 1 to 10,000. ## `surfaces` (type: `array`): Filter to one or more surfaces. Leave empty for all surfaces. ## `fromDate` (type: `string`): Inclusive earliest match date, YYYY-MM-DD. ## `toDate` (type: `string`): Inclusive latest match date, YYYY-MM-DD. ## `proxyConfiguration` (type: `object`): Optional. Tennis Abstract is a small, unauthenticated public site that does not require a proxy for normal use — leave this off unless you're running very high volumes. ## Actor input object example ```json { "playerSlugs": [ "NovakDjokovic" ], "startUrls": [], "maxItems": 10, "surfaces": [], "fromDate": "", "toDate": "", "proxyConfiguration": { "useApifyProxy": false } } ``` # Actor output Schema ## `dataset` (type: `string`): No description # 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 = { "playerSlugs": [ "NovakDjokovic" ], "startUrls": [], "maxItems": 10, "surfaces": [], "fromDate": "", "toDate": "", "proxyConfiguration": { "useApifyProxy": false } }; // Run the Actor and wait for it to finish const run = await client.actor("parsebird/tennis-abstract-match-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 = { "playerSlugs": ["NovakDjokovic"], "startUrls": [], "maxItems": 10, "surfaces": [], "fromDate": "", "toDate": "", "proxyConfiguration": { "useApifyProxy": False }, } # Run the Actor and wait for it to finish run = client.actor("parsebird/tennis-abstract-match-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 '{ "playerSlugs": [ "NovakDjokovic" ], "startUrls": [], "maxItems": 10, "surfaces": [], "fromDate": "", "toDate": "", "proxyConfiguration": { "useApifyProxy": false } }' | apify call parsebird/tennis-abstract-match-scraper --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "command": "npx", "args": [ "mcp-remote", "https://mcp.apify.com/?tools=parsebird/tennis-abstract-match-scraper", "--header", "Authorization: Bearer " ] } } } ``` ## OpenAPI specification Download the OpenAPI definition: https://api.apify.com/v2/actors/Pyaf53DO9iuwiS9HB/builds/TJQ3x3qYZnvJE5Bh7/openapi.json