# TennisExplorer Match Results Scraper (`parseforge/tennisexplorer-scraper`) Actor

Scrapes TennisExplorer match results by date and tour. Returns each match as a flat row with set-by-set scores, odds, and player details. Export to CSV, JSON, Excel, or XML.

- **URL**: https://apify.com/parseforge/tennisexplorer-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Automation, Developer tools, Other
- **Stats:** 308 total users, 151 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $6.79 / 1,000 results

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

[![ParseForge](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner.jpg)](https://apify.com/parseforge?fpr=vmoqkp)

### TennisExplorer Match Results Scraper

**Scrape tennis match results from TennisExplorer for any date and tour, up to a million matches per run.** Every row includes player names, set scores, match stats, and tournament details. No login or API key. Export to CSV, JSON, Excel, or XML.

TennisExplorer publishes detailed match results for ATP and WTA tours, but manually copying scores or building your own parser is slow and fragile. This Actor reads the public results pages directly for any date you choose, filters by men's or women's tour, and returns every match in a clean, flat schema. It handles tiebreaks, retirements, and walkovers so your dataset is ready for analysis.

| Who uses it | What they scrape TennisExplorer for |
|---|---|
| Sports analysts | Building a historical database of match outcomes for player performance models. |
| Betting modelers | Gathering match results to backtest betting strategies against real outcomes. |
| Tennis journalists | Pulling daily results to populate match reports and roundups. |
| App developers | Feeding a tennis scores app with structured match data from any date. |

### What it does

This Actor collects tennis match results from TennisExplorer by date and tour, and returns each match as a flat row with players, scores, and tournament info.

- 📅 **Date-driven scraping:** pick any past date in YYYY-MM-DD format, or leave empty for today's results.
- 🎾 **Tour filter:** choose ATP (men), WTA (women), or both tours in a single run.
- 📊 **Structured output:** every match returns player names, set scores, match stats, and tournament details in a fixed schema.

Results export to CSV, JSON, Excel, or XML, or straight from the API.

### What you can do with TennisExplorer data

**📈 Build a historical match database.**

A sports analyst runs the Actor for every date in the past five years, collecting ATP and WTA results to train an Elo-based player ranking model.

**📰 Populate a daily tennis roundup.**

A journalist runs the Actor each morning for yesterday's date, gets all match results, and feeds them into an automated match-report template.

**💰 Backtest betting models.**

A bettor scrapes a full season of WTA results, joins them with odds data, and measures the profitability of a surface-based betting strategy.

**📱 Power a tennis scores app.**

A developer schedules the Actor to run hourly, pulling the latest completed matches from TennisExplorer and pushing them to a mobile app's results feed.

### Why choose this scraper

| | What you get |
|---|---|
| **No API key needed** | Reads public TennisExplorer pages directly, no registration or OAuth. |
| **Handles edge cases** | Tiebreaks, retirements, and walkovers are parsed into the standard schema. |
| **Flexible volume** | Collect one day of results or build a multi-year archive with repeated runs. |

### How it compares

Two other TennisExplorer scrapers on Apify include odds and rankings data, while this Actor focuses on match results with a simple date-and-tour input.

| Feature | ParseForge | Tennisexplorer Scraper - matches, odds, rankings | TennisExplorer Scraper - Odds, Line Movement, Players, H2H |
|---|---|---|---|
| Match results by date | Yes | Yes | Yes |
| Tour filter (ATP/WTA/both) | Yes | Not listed | Not listed |
| Set-by-set scores with tiebreaks | Yes | Yes | Yes |
| Match statistics (aces, double faults, etc.) | Yes | Not listed | Not listed |
| Decimal odds | Not listed | Yes | Yes |
| Per-bookmaker odds history and line movement | Not listed | Yes | Yes |
| Player profiles and head-to-head records | Not listed | Not listed | Yes |

### Configure the run

Drive the Actor with a date and a tour filter, and set a maximum number of matches to cap the run. The Input tab lists every parameter.

A first run with the defaults:

```json
{
 "maxItems": 10
}
```

A larger pull:

```json
{
 "maxItems": 200
}
```

### Pricing

Pay-per-result: **$0.0075 per result** collected. You pay only for the results written to your dataset.

| Results collected | Approximate cost |
|---|---|
| 100 results | $0.75 |
| 1,000 results | $7.50 |
| 10,000 results | $75.00 |

New Apify accounts start with $5 in free credit.

### Free users

Free-plan runs return up to 10 results as a preview. [Upgrade your Apify plan](https://console.apify.com/sign-up?fpr=vmoqkp) to collect up to 1,000,000 results per run.

### Run it

1. [Create a free Apify account with $5 in credit](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the [TennisExplorer Match Results Scraper](https://apify.com/parseforge/tennisexplorer-scraper?fpr=vmoqkp).
3. Set your inputs and any filters, then click **Start**.
4. Export the results as CSV, Excel, JSON, or XML from the **Dataset** tab.

Run it programmatically through the [Apify API](https://docs.apify.com/api/v2) (`run-sync-get-dataset-items`) or the [ApifyClient](https://docs.apify.com/api/client/js) for JavaScript and Python.

### Use with AI agents (MCP)

Give an AI agent live access to TennisExplorer through the Model Context Protocol. Add the Actor to Claude, Cursor, or any MCP client:

```bash
claude mcp add --transport http apify "https://mcp.apify.com/?tools=parseforge/tennisexplorer-scraper"
```

Then prompt it in plain language to run the scraper and read back the results.

### Troubleshooting

**Why am I getting no results for a date I know had matches?**

Check that the date is in YYYY-MM-DD format and that matches for that day are published on TennisExplorer. Some lower-tier tournaments may not appear immediately. Try leaving the date empty to confirm today's results work, then retry your specific date.

**The run is taking too long or timing out.**

Lower the maximum matches setting to reduce the run size. If you need a full day with many tournaments, consider running ATP and WTA separately in two parallel runs.

**Some match stats are missing in the output.**

TennisExplorer does not always publish full statistics for every match, especially on smaller courts or lower-tier events. Missing stats will appear as empty fields in your dataset.

**I'm getting blocked or seeing captchas.**

Increase the run's timeout and consider using Apify's residential proxies for the run. You can also reduce the maximum matches to shorten the run duration and lower the request rate.

### FAQ

| Question | Answer |
|---|---|
| Can I scrape live in-progress matches? | No, this Actor reads the daily results pages, which show completed matches. For live scores you would need a different source. |
| Does it get player statistics like aces and double faults? | Yes, match stats that appear on the TennisExplorer results page, such as aces and double faults, are included in the output when available. |
| How do I scrape multiple dates at once? | Run the Actor once per date. You can queue multiple runs with different date inputs using the Apify API or scheduler. |
| What happens if I leave the date field empty? | The Actor defaults to today's date and scrapes the current day's completed results. |
| Does it include doubles and qualifying matches? | The Actor scrapes whatever matches appear on the selected tour's results page for that date, which typically includes all main-draw singles matches. Doubles and qualifying availability depends on what TennisExplorer publishes. |
| Can I filter by tournament or player? | The input lets you filter by tour and date. For tournament-level or player-level filtering, you can apply those filters to the output dataset after the run. |
| Is there a risk of getting blocked? | The Actor runs on Apify's infrastructure with built-in proxy rotation and reasonable request rates to minimize blocking. For very large jobs, using Apify's residential proxies adds extra protection. |
| What format is the data exported in? | You can export your dataset in CSV, JSON, Excel, XML, or RSS from the Apify platform. |
| Does it handle retirements and walkovers? | Yes, retirements and walkovers are captured in the match result fields so you can distinguish them from completed matches. |
| Can I scrape odds from TennisExplorer? | This Actor focuses on match results. For odds data, consider a dedicated odds scraper or one of the TennisExplorer scrapers that includes odds in its listing. |

### Related actors

Browse the full [ParseForge collection](https://apify.com/parseforge?fpr=vmoqkp) for more scrapers.

🆘 **Need help?** Email parseforge@protonmail.com with your run ID, your input, and what you expected.

⚠️ **Disclaimer.** This Actor is unofficial and is not affiliated with, endorsed by, or sponsored by TennisExplorer.com. It collects only publicly available data. You are responsible for using the collected data in compliance with the source's terms of service and applicable data-protection laws, including GDPR, CCPA, and PIPL. Do not use it to collect personal data unlawfully.

# Actor input Schema

## `date` (type: `string`):

Results day to scrape, in YYYY-MM-DD format. Leave empty for today's results.

## `tour` (type: `string`):

Which tour's results page to scrape.

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

Maximum number of matches to collect per run.

## Actor input object example

```json
{
  "tour": "both",
  "maxItems": 10
}
```

# Actor output Schema

## `results` (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 '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "date": "",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/tennisexplorer-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 = {
    "date": "",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/tennisexplorer-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 '{
  "date": "",
  "maxItems": 10
}' |
apify call parseforge/tennisexplorer-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parseforge/tennisexplorer-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/LcVuTqGxOfOptjLDP/builds/iQdphuHbQ6XpVKacC/openapi.json