# WTA Singles, Doubles & Race Rankings Finder (`dataspryva/wta-singles-doubles-and-race-rankings-finder`) Actor

Get the official WTA singles, doubles, or Race to the Finals rankings with points, nationality, and player profile links, filterable by player name.

- **URL**: https://apify.com/dataspryva/wta-singles-doubles-and-race-rankings-finder.md
- **Developed by:** [Dataspryva](https://apify.com/dataspryva) (community)
- **Categories:** Automation, Developer tools, Other
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.49 / 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.
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?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## WTA Singles, Doubles & Race Rankings Finder

Collect the official WTA rankings, player biographies, match results, and tournament calendar from wtatennis.com as clean structured records. Every run is cookieless and uses WTA's own public JSON feed, so there is no login, API key, or proxy setup.

### What you can collect

| Mode | What it returns |
|---|---|
| `rankings` | One row per ranked player or doubles team from the singles table, doubles table, Race to the WTA Finals singles table, or Race to the WTA Finals doubles table |
| `profiles` | One row per player with biography, career prize money, current and highest rankings, career win/loss records by level, and optional weekly ranking history |
| `matches` | One row per match in a player's career, with tournament, round, opponent, partner, score, ranking, and prize money |
| `tournaments` | One row per tournament in a date window, with tier, surface, draw sizes, prize money, champions, and optional full match list |

### Rankings

Choose a `rankingType`:

- `singles` and `doubles` — the weekly WTA world rankings
- `raceSingles` and `raceDoubles` — the season-long Race to the WTA Finals standings

Rankings can be filtered by player name and nationality, or read as of a historical Monday with `rankingDate`. The singles table has about 1,550 players, doubles about 1,800, Race singles about 350, and Race doubles about 160 teams.

**Output fields:** `ranking`, `movement`, `playerId`, `playerName`, `firstName`, `lastName`, `nationality`, `points`, `tournamentsPlayed`, `birthDate`, `age`, `rankedAt`, `rankingDate`, `imageUrl`, `profileUrl`, `rankingType`, `recordType`, `scrapedAt`.

Doubles Race rows describe a team: `playerIds`, `playerNames`, `nationalities`, `teamName`, and `teamPlayers` sit beside the first player's `playerId`, `playerName`, and `profileUrl`. Fields WTA does not publish for a row are omitted, never blank.

### Player profiles

Pass WTA player IDs or profile URLs in `playerIds`, or use `searchQuery` with a `rankingType` to look players up by name. `includeRankingHistory` adds up to 52 weeks of ranking movement.

**Output fields:** identity (`playerId`, `playerName`, `firstName`, `lastName`, `nationality`, `countryName`, `birthDate`, `age`, `birthCity`, `height`, `playHand`, `backhand`, `residence`, `status`, `profileUrl`, `imageUrl`), rankings (`singlesRank`, `doublesRank`, `singlesHighRank`, `singlesHighRankDate`, `doublesHighRank`, `doublesHighRankDate`), money (`careerPrizeMoneyUsd`, `prizeMoneyYearToDateUsd`), career summaries (`singlesCareer`, `doublesCareer`, `singlesYearToDate`, `doublesYearToDate`), `recordsByLevel`, biography text, and optional `rankingHistory`.

### Match history

Pass player IDs or profile URLs, or use `searchQuery`, and optionally limit to one season with `year`. Match records include `tournamentName`, `tournamentId`, `tournamentLevel`, `tournamentYear`, `tournamentUrl`, `startDate`, `surface`, `city`, `country`, `round`, `result`, `scores`, `opponentId`, `opponentName`, `opponentNationality`, `partnerId`, `partnerName`, `playerRank`, `opponentRank`, `seed`, `points`, `prizeMoneyUsd`, and `matchType`.

### Tournaments

Set `fromDate` and `toDate` (default: last 7 days through the next 14 days), then filter with `level` and `surface`. `All levels` includes ITF events; pick a specific tier to narrow the calendar. Turn on `includeTournamentMatches` to attach each tournament's match list. Records include `tournamentId`, `tournamentName`, `tournamentTitle`, `year`, `level`, `startDate`, `endDate`, `surface`, `inOutdoor`, `city`, `country`, `singlesDrawSize`, `doublesDrawSize`, `prizeMoney`, `prizeMoneyCurrency`, `status`, `tournamentUrl`, `championSingles`, and `championDoubles`.

### Examples

Top 10 of the singles rankings:

```json
{ "mode": "rankings", "rankingType": "singles", "maxItems": 10 }
```

Find a player in the doubles rankings:

```json
{ "mode": "rankings", "rankingType": "doubles", "searchQuery": "Siniakova", "maxItems": 5 }
```

Historical Race standings:

```json
{ "mode": "rankings", "rankingType": "raceSingles", "rankingDate": "2025-11-03", "maxItems": 20 }
```

Player profiles by URL:

```json
{
  "mode": "profiles",
  "playerIds": ["https://www.wtatennis.com/players/324166/elena-rybakina"],
  "includeRankingHistory": true
}
```

One season of match results:

```json
{ "mode": "matches", "playerIds": ["324166"], "year": 2026, "maxItems": 100 }
```

Grand Slam calendar with matches:

```json
{
  "mode": "tournaments",
  "fromDate": "2026-01-01",
  "toDate": "2026-12-31",
  "level": "Grand Slam",
  "includeTournamentMatches": true
}
```

### How pagination works

The actor follows WTA's own pagination at 100 records per request and stops at `maxItems`, when the source is exhausted, or after a protective page ceiling. Ranking and tournament totals are small enough that one run can collect every row. Duplicate rows are removed by a natural key before pushing.

### FAQ

**Do I need a WTA account, key, or proxy?**
No. The actor reads WTA's public JSON feed directly without cookies or credentials.

**How current are the rankings?**
They match the latest rankings WTA has published, normally updated weekly. Set `rankingDate` to a Monday from 2001 onward for historical standings.

**Why is a field missing on one record?**
WTA does not publish every biographical, image, or champion field for every player and tournament. Missing values are left out instead of appearing as `null` or an empty string.

**Why do some players have no photo?**
WTA only publishes headshots for part of the tour. The actor uses WTA's official photo feed and omits `imageUrl` when no photo exists.

**What is the difference between the rankings and the Race?**
The regular rankings use a rolling 52-week points window. The Race counts only the current season and decides who qualifies for the WTA Finals.

**Can one run mix modes?**
No. One run returns one record type. Run the actor again with another `mode` for a different dataset.

**Is this affiliated with the WTA?**
No. This is an independent third-party actor that reads publicly available WTA data. It is not operated by the Women's Tennis Association.

# Actor input Schema

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

Choose rankings, player profiles, match history, or the tournament calendar.

## `rankingType` (type: `string`):

Singles, doubles, Race to the WTA Finals singles, or Race to the WTA Finals doubles. Also used to resolve names in profiles and matches modes.

## `rankingDate` (type: `string`):

Historical rankings as of a Monday from 2001 onward. Leave empty for the latest published rankings.

## `searchQuery` (type: `string`):

Filter rankings by name, or resolve players for profiles and matches modes.

## `nationality` (type: `string`):

Three-letter country code such as USA, POL, or KAZ.

## `playerIds` (type: `array`):

Profiles and matches modes. Paste WTA player IDs or profile URLs, one per line or comma-separated.

## `year` (type: `integer`):

Matches mode only. Limit match history to one season, for example 2026.

## `fromDate` (type: `string`):

Tournaments mode. Start of the calendar window; leave empty for the last 7 days.

## `toDate` (type: `string`):

Tournaments mode. End of the calendar window; leave empty for the next 14 days.

## `level` (type: `string`):

Tournaments mode. Filter by WTA tournament tier.

## `surface` (type: `string`):

Tournaments mode. Filter by court surface.

## `includeTournamentMatches` (type: `boolean`):

Tournaments mode. Add the match list for every returned tournament.

## `includeRankingHistory` (type: `boolean`):

Player profiles mode. Add up to 52 weeks of singles, doubles and Race ranking history.

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

Stop after this many records. Each ranking table has at most about 1,800 players.

## Actor input object example

```json
{
  "mode": "rankings",
  "rankingType": "singles",
  "level": "all",
  "surface": "all",
  "includeTournamentMatches": false,
  "includeRankingHistory": false,
  "maxItems": 3
}
```

# Actor output Schema

## `records` (type: `string`):

Dataset containing ranking, player profile, match or tournament records depending on the selected mode.

# 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 = {
    "mode": "rankings",
    "rankingType": "singles",
    "level": "all",
    "surface": "all",
    "includeTournamentMatches": false,
    "includeRankingHistory": false,
    "maxItems": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("dataspryva/wta-singles-doubles-and-race-rankings-finder").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 = {
    "mode": "rankings",
    "rankingType": "singles",
    "level": "all",
    "surface": "all",
    "includeTournamentMatches": False,
    "includeRankingHistory": False,
    "maxItems": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("dataspryva/wta-singles-doubles-and-race-rankings-finder").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 '{
  "mode": "rankings",
  "rankingType": "singles",
  "level": "all",
  "surface": "all",
  "includeTournamentMatches": false,
  "includeRankingHistory": false,
  "maxItems": 3
}' |
apify call dataspryva/wta-singles-doubles-and-race-rankings-finder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,dataspryva/wta-singles-doubles-and-race-rankings-finder"
        }
    }
}
```

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/FfvK5ZNrnzzwNGqjP/builds/SoLkS2bfHeLPFw327/openapi.json