# Tennis Match Intelligence – Live Scores & Fixtures (`fetchfinch/tennis-match-monitor`) Actor

Get normalized live and upcoming ATP, WTA, Challenger, and ITF tennis matches without supplying an API key. Filter by player, tournament, date, status, or match format, monitor score changes, and deliver signed webhook alerts.

- **URL**: https://apify.com/fetchfinch/tennis-match-monitor.md
- **Developed by:** [FetchFinch](https://apify.com/fetchfinch) (community)
- **Categories:** Other, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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 Live Scores & Fixtures

Get normalized live and upcoming tennis matches without supplying an external API key. Query ATP, WTA, Challenger, and ITF-level coverage, filter the feed, track meaningful changes across runs, and send signed webhook alerts to your workflow.

### What you can collect

- Live tennis matches and scores
- Upcoming ATP and WTA fixtures
- ATP, WTA, Challenger, and ITF-level events available in the feed
- Singles and doubles matches
- Player, tournament, round, status, score, and start-time data
- Stable match IDs for integrations and recurring monitoring
- Cache freshness metadata on every result

Results use a consistent JSON structure across tours so they can be sent directly to databases, dashboards, spreadsheets, alerting systems, and data pipelines.

### Quick start

#### Current live matches

```json
{
  "mode": "liveMatches",
  "emit": "all",
  "maxItems": 100
}
```

#### Upcoming singles fixtures for a date

```json
{
  "mode": "upcomingMatches",
  "date": "2026-08-11",
  "formats": ["singles"],
  "maxItems": 200
}
```

#### Find matches involving a player

```json
{
  "mode": "allCachedMatches",
  "playerQuery": "Sinner",
  "emit": "all",
  "maxItems": 100
}
```

### Monitor match changes

Set a stable `monitorId` and schedule the Actor with the same input. The Actor remembers the previous snapshot and can emit only new or changed matches.

```json
{
  "mode": "liveMatches",
  "playerQuery": "Sinner",
  "monitorId": "sinner-live",
  "emit": "changes",
  "maxCacheAgeMinutes": 90
}
```

Detected changes include:

- `newMatch`
- `scoreChanged`
- `statusChanged`
- `startTimeChanged`
- `oddsChanged` when odds are available

The first run of a new monitor treats matching records as new. Later runs compare them with the saved monitor state.

### Send webhook alerts

Provide an HTTPS endpoint to receive one JSON batch whenever matching changes are emitted.

```json
{
  "mode": "liveMatches",
  "tournamentQuery": "Montreal",
  "monitorId": "montreal-live",
  "emit": "changes",
  "webhookUrl": "https://example.com/tennis-alerts",
  "webhookSecret": "YOUR_SIGNING_SECRET"
}
```

When `webhookSecret` is supplied, the request includes an `X-Tennis-Monitor-Signature` HMAC-SHA256 signature.

### Filters

You can combine the following inputs:

- `mode`: live matches, upcoming matches, or both
- `date`: UTC match date in `YYYY-MM-DD` format
- `eventIds`: match IDs returned by an earlier run
- `playerQuery`: case-insensitive player or team name
- `tournamentQuery`: case-insensitive tournament name
- `statuses`: in progress, not started, finished, canceled, or postponed
- `formats`: singles or doubles
- `maxItems`: maximum number of results

### Output

Each dataset item represents one match and includes:

- Match and source identifiers
- Tournament, season, and round
- Home and away players or doubles teams
- Match status and scheduled start time
- Set, game, and point score information when available
- Match format and surface when available
- Optional odds, statistics, timeline, and point-by-point fields
- Monitoring change types
- Cache freshness information

Important freshness fields:

- `cacheUpdatedAt`: when the managed snapshot was refreshed
- `cacheAgeSeconds`: snapshot age when the Actor ran
- `isCacheStale`: whether it exceeds your `maxCacheAgeMinutes` threshold

Stale records are returned rather than silently discarded, allowing workflows to detect a delayed refresh without losing the last available snapshot.

### Coverage and freshness

Live snapshots are currently refreshed approximately hourly. Upcoming fixtures are refreshed twice daily. These intervals may improve as demand grows.

Coverage varies by tour, tournament, and match. Odds, statistics, timelines, surface information, and point-by-point data are optional and can be `null`. Do not treat the Actor as an official scoring service or use it where delayed or incomplete sports data could create safety-critical or financial risk.

### Usage notes

- No external API credential is required from customers.
- Use `emit: "all"` for complete filtered snapshots.
- Use `emit: "changes"` with a stable `monitorId` for scheduled monitoring.
- Check `isCacheStale` when freshness is important to your workflow.
- Use narrow filters and an appropriate `maxItems` value to keep datasets compact.

This Actor aggregates data supplied by independent third-party data services. It is not affiliated with or endorsed by ATP, WTA, ITF, or any tournament organizer.

# Actor input Schema

## `mode` (type: `string`):

Choose the managed live cache, upcoming fixtures, or both.

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

Optional UTC start-date filter in YYYY-MM-DD format.

## `eventIds` (type: `array`):

Optional normalized or source match IDs returned by an earlier run.

## `playerQuery` (type: `string`):

Optional case-insensitive text matched against either player or doubles team.

## `tournamentQuery` (type: `string`):

Optional case-insensitive text matched against tournament names.

## `statuses` (type: `array`):

Optional status filter. Leave empty to return every status in the selected cache.

## `formats` (type: `array`):

Optional singles/doubles filter.

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

Maximum number of records after filtering.

## `maxCacheAgeMinutes` (type: `integer`):

Records older than this are marked isCacheStale=true; they are still returned so temporary refresh failures do not break workflows.

## `monitorId` (type: `string`):

Optional stable name for recurring runs. It enables new-match, score, status, start-time, and odds change detection.

## `emit` (type: `string`):

With a monitor ID, return all matches or only new/changed matches.

## `minOddsProbabilityChange` (type: `number`):

Suppress oddsChanged unless implied probability moves by at least this amount. 0.03 means 3 percentage points.

## `webhookUrl` (type: `string`):

Optional HTTPS endpoint that receives one JSON batch when monitor changes are emitted.

## `webhookSecret` (type: `string`):

Optional HMAC-SHA256 secret for X-Tennis-Monitor-Signature.

## Actor input object example

```json
{
  "mode": "liveMatches",
  "eventIds": [],
  "statuses": [],
  "formats": [],
  "maxItems": 100,
  "maxCacheAgeMinutes": 90,
  "emit": "changes",
  "minOddsProbabilityChange": 0.03
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("fetchfinch/tennis-match-monitor").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("fetchfinch/tennis-match-monitor").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 '{}' |
apify call fetchfinch/tennis-match-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,fetchfinch/tennis-match-monitor"
        }
    }
}

```

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/O7OsFx7HDfBSBNiE7/builds/5L2IohjnvOC6bj9so/openapi.json