# TennisExplorer Match Results Scraper (`fetch_cat/tennisexplorer-match-results-scraper`) Actor

Export public TennisExplorer match results by date and tour, with players, scores, set results, tournament context, odds, and source links.

- **URL**: https://apify.com/fetch\_cat/tennisexplorer-match-results-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** Developer tools, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.48 / 1,000 match result exporteds

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 Match Results Scraper for TennisExplorer

This tennis match results scraper exports public TennisExplorer results for one or more dates and tours. Get tournament context, both players, final and set scores, and publicly displayed odds in clean dataset rows for a reliable tennis results API workflow.

### Who is it for?

This TennisExplorer scraper is for tennis analysts, sports-data teams, journalists, and developers who need a repeatable export of completed matches shown publicly on TennisExplorer.

Use it to create a date-based result archive, refresh a daily ATP or WTA feed, or send normalized match rows to a spreadsheet, database, dashboard, or AI workflow.

### What it exports

Each match row includes the requested date, tour filter, tournament and match links, TennisExplorer match ID, player names and links, winner, final score, set-by-set score pairs, and odds where they are publicly displayed.

- **Match identity:** source URL, match URL, and match ID.
- **Tournament context:** tournament name, tournament URL, selected tour, and requested date.
- **Players and result:** both player names, public profile links, winner, score, and set scores.
- **Optional public values:** odds, round, and status only when they are shown in the source result list.

### Input recipes

#### Daily ATP and WTA results

```json
{
  "dates": ["2026-08-27"],
  "tours": ["atp-single", "wta-single"],
  "maxItems": 50
}
```

#### Multi-day results archive

```json
{
  "dates": ["2026-08-27", "2026-08-26"],
  "tours": ["all"],
  "maxItems": 100
}
```

#### One tour with a small export limit

```json
{
  "dates": ["2026-08-27"],
  "tours": ["wta-single"],
  "maxItems": 20
}
```

### Input settings

| Input | Description |
| --- | --- |
| `dates` | Required list of dates in `YYYY-MM-DD` format. |
| `tours` | Optional list: `all`, `atp-single`, `atp-double`, `wta-single`, `wta-double`, or `mix`. |
| `maxItems` | Maximum matches to save across the whole run. Start with a small limit while testing a workflow. |
| `includeMatchDetails` | Reserved for a future public-detail enrichment option. The current release exports the public result-list fields described below. |

### Output fields

| Field | Description |
| --- | --- |
| `sourceUrl` | Public results page used for the row. |
| `matchUrl` | Public TennisExplorer match page URL. |
| `matchId` | TennisExplorer match identifier from the public match link. |
| `tournamentName`, `tournamentUrl` | Tournament name and its public link. |
| `tour`, `eventDate` | Selected tour and requested result date. |
| `round`, `status` | Nullable when the result list does not expose a value. |
| `player1Name`, `player1Url` | First displayed player and public profile URL when available. |
| `player2Name`, `player2Url` | Second displayed player and public profile URL when available. |
| `winnerName` | Winner when it is identifiable from the public result. |
| `score`, `setScores` | Result summary and set pairs such as `7-5`. |
| `odds` | Displayed pre-match player odds when both values are available. |

### Example output

```json
{
  "eventDate": "2026-08-27",
  "tour": "atp-single",
  "tournamentName": "US Open",
  "player1Name": "Player One",
  "player2Name": "Player Two",
  "winnerName": "Player One",
  "score": "2-0",
  "setScores": ["6-4", "6-3"],
  "odds": { "player1": 1.62, "player2": 2.3 },
  "matchUrl": "https://www.tennisexplorer.com/match-detail/?id=example"
}
```

The example uses illustrative player and match values to show the row shape. Actual availability of odds, round, status, and profile links varies by public result page.

### Tennis results API use cases

- Build historical tennis result datasets by calendar date.
- Monitor daily ATP and WTA completed matches.
- Feed player-performance and score-analysis workflows.
- Join match results to your own player, tournament, or odds data.
- Create scheduled spreadsheet or database imports from an Apify dataset.

### Pricing and limits

This Actor charges one small start event and one item event for every match row saved. Use `maxItems` to control the maximum number of exported rows; see the live [Actor Pricing tab](https://apify.com/fetch_cat/tennisexplorer-match-results-scraper/pricing) for the current tiered per-result price before large exports.

- Use specific tour filters to avoid mixed result lists.
- Results and odds are limited to information publicly visible on TennisExplorer at run time.
- A page that fails is skipped so results from other selected dates can still be saved.
- An empty date or tour can legitimately return no rows when no public completed matches are listed.

### API usage

Run the Actor from the Apify API with your normal Actor input, then download the default dataset as JSON, CSV, Excel, or XML.

#### Node.js

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/tennisexplorer-match-results-scraper').call({
  dates: ['2026-08-27'],
  tours: ['atp-single'],
  maxItems: 20,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("fetch_cat/tennisexplorer-match-results-scraper").call(run_input={
    "dates": ["2026-08-27"],
    "tours": ["wta-single"],
    "maxItems": 20,
})
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/fetch_cat~tennisexplorer-match-results-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"dates":["2026-08-27"],"tours":["atp-single"],"maxItems":20}'
```

### MCP and AI agents

Use this Actor from an MCP-compatible AI client through Apify MCP. Add `?tools=fetch_cat/tennisexplorer-match-results-scraper` to the MCP server URL so your client can discover this Actor as an available tool:

```text
https://mcp.apify.com?tools=fetch_cat/tennisexplorer-match-results-scraper
```

Add the server to Claude Code, then scope tool discovery to this Actor:

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

Or use this MCP configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=fetch_cat/tennisexplorer-match-results-scraper"
    }
  }
}
```

Example prompts:

- "Export up to 20 ATP singles results for 2026-08-27 and summarize the winners."
- "Fetch public WTA singles results for 2026-08-27, retaining source URLs and any displayed odds."

Give the agent a date, one or more tours, and a conservative `maxItems` value. Ask it to retain the returned dataset fields and distinguish unavailable public values from missing data.

### Tips for reliable exports

- Use ISO dates such as `2026-08-27`.
- Start with one date and a low `maxItems` value to validate your downstream mapping.
- Choose `atp-single` or `wta-single` when you need a single competition category.
- Preserve `sourceUrl` and `matchUrl` in downstream data for review and traceability.
- Treat optional values as nullable: public result pages do not display every field for every match.

### FAQ

**Why is `odds` missing?** TennisExplorer does not display odds for every match; the Actor does not invent them.

**Does it require a login?** No. This Actor only requests publicly available result pages.

**How can I export TennisExplorer match results by date?** Add one or more ISO dates to `dates`, choose the tours you need, and set `maxItems` for the whole export.

**Can I use TennisExplorer match results in an API workflow?** Yes. Use the Apify API example above or download the default dataset; each row includes stable match and source links for downstream mapping.

**Why did a selected date return no rows?** The public page may have no completed matches for that date and tour, or may not list the requested result category.

**Can I export the data to a spreadsheet?** Yes. Open the default dataset after a run and download CSV, Excel, JSON, or XML from Apify.

### Data and responsible use

Use this Actor only for public TennisExplorer results and comply with TennisExplorer terms, applicable law, and the limits of the source data. Do not treat a missing public field as a factual value.

### Related Actors

- [MLB Roster & Player Stats Exporter](https://apify.com/fetch_cat/mlb-stats-scraper) for official baseball roster and player statistics.
- [Google Search Results Scraper](https://apify.com/fetch_cat/google-search-results-scraper) for researching public tournament coverage.
- [Google News Scraper](https://apify.com/fetch_cat/google-news-scraper) for monitoring tennis news around matches.
- [Google Trends Scraper](https://apify.com/fetch_cat/google-trends-scraper) for comparing tournament-interest patterns.
- [Google Images Scraper](https://apify.com/fetch_cat/google-images-scraper) for public tennis image research.

### Support

For input or output questions, open an issue from this Actor's Apify page and include the date, tour, and a sample public result URL.

# Actor input Schema

## `dates` (type: `array`):

One or more dates in YYYY-MM-DD format.

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

Tours to export for each date. Select all to include every public result table.

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

Maximum result rows saved across all requested dates and tours.

## `includeMatchDetails` (type: `boolean`):

Reserved for optional public detail-page enrichment. The first release exports result-list fields only.

## Actor input object example

```json
{
  "dates": [
    "2026-08-27"
  ],
  "tours": [
    "all"
  ],
  "maxItems": 20,
  "includeMatchDetails": false
}
```

# Actor output Schema

## `overview` (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 = {
    "dates": [
        "2026-08-27"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/tennisexplorer-match-results-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 = { "dates": ["2026-08-27"] }

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/tennisexplorer-match-results-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 '{
  "dates": [
    "2026-08-27"
  ]
}' |
apify call fetch_cat/tennisexplorer-match-results-scraper --silent --output-dataset

```

## MCP server setup

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