ATP Live Rankings Scraper: 70 of 70 Runs Succeeded (2026)

Each record carries 10 fields, including player name, country code, age, live points or prize money in USD, and ranking position across 5 distinct list types. A thousand results cost $5.00 on Apify's free plan, which includes $5.00 of monthly prepaid usage. You can fetch live singles, doubles, Race to ATP Finals, Next Gen race, or year-to-date prize money standings, updated in real time as match results complete. This Actor is built for sports analysts, editorial media teams, and fantasy sports developers who need current ATP standings. It is not for anyone who requires historical match statistics or detailed head-to-head records, which the output dataset does not include.

Try it before you read further. Apify's free plan includes $5.00 of usage every month with no credit card, enough for up to 1,000 results at $0.005 each before platform usage. Open ATP Live Rankings Scraper on Apify and run the prefilled example.

How reliable is ATP Live Rankings Scraper in production?

Across the last 30 days of public runs on the Apify platform, ATP Live Rankings Scraper recorded 70 runs with the following outcomes.

Outcome	Runs	Share
Succeeded	70	100.0%
Failed	0	0.0%
Aborted by the user	0	0.0%
Timed out	0	0.0%
Total	70	100.0%

In the last 30 days across 70 public runs, 70 succeeded with no runs failing or timing out. Zero runs failed or timed out in this period. When scheduling automated runs, you do not need complex error handling for failures, but standard retry configurations on your API client remain good practice.

What does it cost to run ATP Live Rankings Scraper?

Each result costs $0.005 on Apify's free plan, which is $5.00 per 1,000 results. Starting a run is charged separately at $0.005 per GB of Actor memory. Apify also bills the platform usage each run consumes, at the rates of your Apify plan, on top of these charges.

Apify plan	Per result	Per 1,000 results
FREE	$0.005	$5.00
BRONZE	$0.00433	$4.33
SILVER	$0.00367	$3.67
GOLD	$0.003	$3.00
PLATINUM	$0.003	$3.00
DIAMOND	$0.003	$3.00

Worked example: collecting 10,000 results costs $50.00 in result charges before run-start fees and platform usage. No run failed or timed out in the last 30 days, so the list price is a fair budget; keep a retry in place all the same.

The maxItems parameter directly controls your dataset size and overall charge. Set maxItems conservatively during initial testing, as the default value of 100 keeps result costs capped at $0.50 per run. Switching between ranking types or applying a country code filter changes which records are fetched, but only total dataset items dictate result fees.

How do you run ATP Live Rankings Scraper from the API?

None of its 3 controls is strictly required, so the defaults below produce a valid run on their own. The payload below uses the schema's own prefilled values, so it runs as written once you substitute your API token.

Call the synchronous endpoint to start a run and receive dataset items in one request:

curl -X POST "https://api.apify.com/v2/acts/crawlerbros~atp-live-tennis-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"rankType":"singles","maxItems":100}'

The same run from Python, using the official client:

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run_input = {
  "rankType": "singles",
  "maxItems": 100
}

run = client.actor("crawlerbros~atp-live-tennis-scraper").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

And from Node.js:

import { ApifyClient } from 'apify-client'

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' })

const input = {
  "rankType": "singles",
  "maxItems": 100
}

const run = await client.actor('crawlerbros~atp-live-tennis-scraper').call(input)
const { items } = await client.dataset(run.defaultDatasetId).listItems()
console.log(items)

The synchronous endpoint holds the connection open until the run finishes, which is convenient for small batches and wrong for large ones. For anything long running, start the run asynchronously and poll, or attach a webhook, so a dropped connection does not cost you the results.

Which ATP Live Rankings Scraper inputs matter, and which can you skip?

The primary control to configure is rankType, which selects between live singles, live doubles, race, race-next-gen, and prize-money lists. Use countryCode only when you want to narrow results to a specific nation using a 3-letter code like ITA or ESP. Leave countryCode blank on your first run and keep maxItems at 100 to evaluate the default singles output.

rankType (string): Which ATP ranking list to scrape. Default: "singles".
countryCode (string): Filter by nationality, e.g. ITA, ESP, USA, SRB. Leave blank for all countries.
maxItems (integer): Hard cap on emitted records. Default: 100.

Fixed-choice controls: rankType accepts singles (live rankings), doubles (live rankings), race (Race to ATP Finals), race-next-gen (Next Gen Race), prize-money (YTD Prize Money).

What does ATP Live Rankings Scraper return?

The dataset returns 10 fields per player, including rank, playerName, country, age, points, profileUrl, and scrapedAt. It provides a clean snapshot of live rankings that updates faster than official weekly releases. It does not include historical ranking history by date, individual match scores, or point breakdowns per tournament.

rank: Integer - Current ATP ranking position
playerName: String - Full player name
country: String - 3-letter country code (e.g., ITA)
age: Integer - Player age
points: Integer - ATP ranking points (or prize money in USD for prize-money type)
rankType: String - Ranking table type scraped
profileUrl: String - Player profile URL on live-tennis.eu
recordType: String - Always ranking
scrapedAt: String - ISO 8601 timestamp
sourceUrl: String - Source page URL

These are the documented fields. Optional ones can be empty on a given record, so measure how often each field your deliverable depends on is populated across a real sample before automating the handoff.

How do you build the workflow end to end?

Open ATP Live Rankings Scraper and work through these in order. Each step ends with something to check, so a bad configuration surfaces on a small run rather than a scheduled one.

Set rankType to singles, doubles, race, race-next-gen, or prize-money depending on which live leaderboard you need.
Set countryCode to a 3-letter uppercase country code like ITA, ESP, or USA to filter by player nationality, or leave it blank to fetch all nationalities.
Set maxItems to 100 for an initial test run, keeping result charges capped at $0.50.
Execute the run and verify that the dataset contains records with a recordType value of ranking.
Inspect the returned fields to ensure rank, playerName, country, age, and points are present for every record.
Increase maxItems up to 2000 if you need to capture the full list of over 1,000 active players in the ATP standings.
Configure an Apify schedule to run the Actor automatically during active tournament weeks to track live points and rank adjustments.

How do you apply it? Three worked playbooks

These are ATP Live Rankings Scraper's own documented use cases, each worked through as an operating pattern rather than a description.

Use case 1: Analytics and betting research

Outcome: Tennis analytics and betting research

Configure: Set rankType to singles, leave countryCode blank, and set maxItems to 2000 to capture the entire live ATP singles field.

Working method: Execute the run at the start of a tournament week to establish a baseline dataset of current points and rankings. Export the dataset items into your analytical database to correlate ranking positions with odds models. Repeat the run after major tournament rounds to track real-time points accumulation.

Deliverable: A structured dataset of up to 2,000 active ATP players with current points, ranks, ages, and countries.

Stop condition: The returned dataset contains fewer than 100 records when maxItems is set to 2000.

Use case 2: Sports media and editorial

Outcome: Sports media and editorial applications

Configure: Set rankType to race or race-next-gen and set maxItems to 20 to focus on top contenders for the season-ending finals.

Working method: Run the Actor immediately following key tournament matches to obtain updated standings before official weekly releases. Compare the returned ranks and points against previous week standings to write match coverage and point projections.

Deliverable: A clean list of top 20 race leaders with updated points and ranks ready for publishing in editorial tables or graphics.

Stop condition: The playerName field is null or empty in any of the top 20 records.

Use case 3: Real-time ranking tracking

Outcome: Tracking ATP player ranking changes in real time

Configure: Set rankType to singles, set countryCode to a specific code like ITA, and set maxItems to 100.

Working method: Schedule the Actor to run hourly during ongoing tournament play. Compare the newly generated dataset against the previous run's dataset by matching on profileUrl to detect immediate point or rank changes.

Deliverable: A historical time-series dataset of ranking and point fluctuations for targeted national players across active tournament dates.

Stop condition: The scrapedAt timestamp is duplicate or out of order across consecutive automated runs.

What breaks, and how do you design around it?

Over the last 30 days, 0.0% of public runs failed and 0.0% timed out. Build retries and alerting around those rates rather than assuming every run completes.

When you need the entire list of ranked tennis professionals, set maxItems to 2000, as the full ATP singles standings contain over 1,000 active players. If you filter heavily by countryCode and receive empty datasets, verify that you are passing valid 3-letter codes like USA, ITA, or SRB. For non-tennis sports or match scoreboards, use a dedicated multi-sport collector instead.

When should you not use ATP Live Rankings Scraper?

Do not use this Actor if you require historical ranking histories across previous years or detailed match play-by-play data, as it only returns current live ranking tables from live-tennis.eu. If you need historical match scores, team standings, or broad multi-sport coverage across major leagues, use ESPN Scraper, 365Scores Sports Data Scraper, or FlashScore Live Sports Scraper. If your project focuses on player prize earnings across esports tournaments rather than ATP professional tennis, Esports Earnings Scraper is the appropriate tool.

What should you check before trusting the output?

Verify that rank contains incremental integers starting at 1 with no unexpected gaps.
Check that points is a non-null integer representing ATP ranking points or USD earnings when rankType is set to prize-money.
Ensure country consists strictly of 3-letter country codes such as ITA or ESP rather than full country names or blank strings.
Validate that age contains plausible integer values for professional tennis players, typically between 15 and 50.
Stop scheduled runs if recordType is missing or returns a value other than ranking.

None of this proves a record is correct. It gives a scheduled ATP Live Rankings Scraper run defined points where it should stop instead of quietly passing bad data downstream.

Frequently asked questions

How much does it cost to scrape ATP live rankings?

This Actor costs $0.005 per result, which equals $5.00 per 1,000 results on Apify's free plan. Apify's free plan provides $5.00 in monthly usage with no credit card required, covering up to 1,000 results. The example input caps maxItems at 100, costing at most $0.50 in result charges per run.

What is the difference between live rankings and official ATP rankings?

Live rankings update continuously as tournament match results are recorded throughout the week. Official ATP rankings are published once per week on Mondays. Live rankings reflect virtual points and position shifts before official releases occur.

How do I fetch year-to-date prize money rankings?

Set the rankType input field to prize-money. When this mode is active, the points field in each returned record represents total year-to-date prize money earned by the player in USD.

Can I filter ATP live rankings by player nationality?

Yes. Pass a 3-letter country code into the countryCode input field. Examples include ITA for Italy, ESP for Spain, USA for the United States, or SRB for Serbia.

How many records can I retrieve in a single run?

You can retrieve up to 2,000 records per run by setting maxItems to 2000. Because the full ATP singles list contains over 1,000 players, setting maxItems to 2000 captures all active ranked players.

Where to go next

When you are ready to run it, open ATP Live Rankings Scraper on Apify; the free plan covers up to 1,000 results a month.

Start with the ATP Live Rankings Scraper Actor page for the current input schema, pricing tier, and run history.

Readers running ATP Live Rankings Scraper commonly pair it with:

Esports Earnings Scraper: Scrape EsportsEarnings.com - cross-game esports prize-money rankings for top players, top teams, top games by total prize pool, and tournament results.
ESPN Scraper: Scrape ESPN public API with scoreboards, standings, teams, news, and game details for NFL, NBA, MLB, NHL, MLS, Premier League, La Liga, F1, UFC, PGA Golf, ATP Tennis, and more.
World Rugby Rankings & Results Scraper: Scrape official World Rugby data - men's and women's world rankings (current or historical by date), match results and fixtures across international and club rugby, and national team profiles.
NCAA.com Stats Scraper: Scrape NCAA.com team statistical leaderboards, individual (player) leaderboards, national ranking polls (AP, NET, RPI, coaches polls, and more), and conference standings for any sport and division.
WalletHub Rankings Scraper: Scrape WalletHub.com's data-driven state/city ranking studies - personal finance, economy, health, safety and lifestyle rankings.
365Scores Sports Data Scraper: Scrape 365Scores (365scores.com) public API for live sports scores, standings, and competition data.
ProCyclingStats Scraper: Scrape ProCyclingStats.com - professional road cycling race results, rider profiles, team rosters, and PCS/UCI rankings.
FlashScore Live Sports Scraper: Scrape live matches from FlashScore for football, basketball, tennis, hockey, baseball and 11 other sports.

Related guides:

Resources

Actor documentation, input schema, and pricing: verified against the published Actor on 2026-09-24.
Actor last updated by its maintainers on 2026-06-11.
Run outcome figures cover the 30 day public window ending 2026-09-24.
ATP Live Rankings Scraper on Apify