# Pickleball Pro Rankings & Results Scraper (`bareezh_codes/pickleball-pro-rankings-results-scraper`) Actor

Pulls live official pro pickleball rankings, player profiles, and tournament-by-tournament match results (game scores, opponents, dates) from pickleball.com, the unified data hub for the PPA/APP/MLP tours.

- **URL**: https://apify.com/bareezh\_codes/pickleball-pro-rankings-results-scraper.md
- **Developed by:** [Salman Bareesh](https://apify.com/bareezh_codes) (community)
- **Categories:** Other, News
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

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

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

Get the official pro **pickleball rankings** — Singles, Doubles, and Mixed Doubles — plus tournament-by-tournament **match results** (game scores, opponents, dates) straight from [pickleball.com](https://pickleball.com), the unified data hub for the PPA, APP, and MLP tours. No login, no browser automation — just live, structured data you can pull on a schedule.

### Why use Pickleball Pro Rankings & Results Scraper?

Pickleball is the fastest-growing sport in the US for five years running (24.3M players in 2025, per SFIA), and sportsbooks (FanDuel, DraftKings) and prediction markets (Polymarket) now list pickleball props and futures. That means live, structured rankings and results data has real commercial demand — but pickleball.com itself has no public API, and the one existing "unified pickleball API" actor on Apify just resells a third-party RapidAPI reseller instead of reading the primary source.

This actor reads pickleball.com directly:

- Pulls the top 100 ranked pro players for **Singles**, **Doubles**, or **Mixed Doubles**, filtered by gender.
- Optionally fetches each ranked player's recent tournament match history — event, opponent(s), per-game scores, and win/loss.
- Runs on the Apify platform, so you get scheduling, API/webhook access, and monitoring out of the box.

Typical use cases:

- **Sports-betting & prediction-market research** — build a current rankings + recent-form feed to inform prop/futures models.
- **Pickleball media & newsletters** (e.g. leaderboard widgets, weekly recap content) — always-current standings without manually checking the site.
- **Fantasy pickleball apps** — player stats and recent match form as a data source.
- **Sponsorship scouting** — paddle/apparel brands tracking ranking trajectories and event activity.

### What data can Pickleball Pro Rankings & Results Scraper extract?

| Field | Type | Description |
|---|---|---|
| `rank`, `points`, `livePoints`, `liveRankingChange` | number | Current ranking position and points |
| `playerFullName`, `playerSlug`, `playerUuid` | string | Player identity |
| `countryAbbreviation`, `age`, `gender` | string/number | Player profile basics |
| `totalEventsPlayed` | number | Career events played (in this division) |
| `recentResults` | array | *(optional)* Tournament-by-tournament match history: event, opponents, per-game scores, W/L |

See [Output](#output) below for the full field reference and a complete real example.

### How to use Pickleball Pro Rankings & Results Scraper

1. Click **Try for free** (or **Run**) on this actor's page.
2. Optionally set `division` (Singles / Doubles / Mixed Doubles) and `gender` (Men / Women / All).
3. Optionally set `maxPlayers` (up to 100) and turn on `includePlayerMatchHistory` for recent results.
4. Click **Start** and wait for the run to finish.
5. Open the **Dataset** tab and export as JSON, CSV, or Excel — or pull it via the **API** tab.

### How much will it cost to use Pickleball Pro Rankings & Results Scraper?

You pay only for ranking rows delivered.

| Your Apify discount tier | Price per result | 1,000 results |
|---|---|---|
| Free | $0.005 | $5 |
| Bronze | $0.0045 | $4.50 |
| Silver | $0.004 | $4 |
| Gold / Platinum / Diamond | $0.0035 | $3.50 |

Apify's free plan includes $5 of monthly credit — enough for 1,000 results at no cost. Pulling the full top-100 doubles rankings daily costs about $0.50/day (~$15/month) on the Free tier.

### Input

All fields are optional — running the actor with an empty input (`{}`) returns the top 100 pro **Doubles** players (all genders). See the **Input** tab for the full configuration schema.

| Field | Type | Default | Description |
|---|---|---|---|
| `division` | string (enum) | `doubles` | `singles`, `doubles`, or `mixed-doubles` |
| `gender` | string (enum) | `all` | `men`, `women`, or `all` |
| `maxPlayers` | integer | `100` | How many ranking rows to return (max 100 — pickleball.com only publishes the top 100 per ranking) |
| `includePlayerMatchHistory` | boolean | `false` | Also fetch each ranked player's recent tournament match results (one extra request per player) |

Example input for "top 10 men's singles players with recent match history":

```json
{
  "division": "singles",
  "gender": "men",
  "maxPlayers": 10,
  "includePlayerMatchHistory": true
}
```

### Output

One item per ranked player, same keys every time (`null` when a field doesn't apply). This is a real item from a live run of this actor (`tests/smoke_input.json`: Singles, all genders, top 3, with match history):

```json
{
  "rank": 1,
  "playerFullName": "Ben Johns",
  "playerSlug": "ben-johns",
  "playerUuid": "6f862c1d-1317-4fe7-bdcd-64caa0dbb088",
  "countryAbbreviation": "USA",
  "age": 27,
  "gender": "M",
  "division": "singles",
  "totalEventsPlayed": 15,
  "points": 21300,
  "livePoints": 21300,
  "livePointsChange": 0,
  "liveRankingChange": 0,
  "profileImageUrl": "https://cdn.pickleball.com/profile-images/1782401495115/BenJohns-5-Edited.png?width=64&height=64&optimizer=image",
  "scrapedAt": "2026-09-14T08:12:02.766526+00:00",
  "recentResults": [
    {
      "eventTitle": "PPA Tour: Veolia Pickleball National Championships",
      "activityTitle": "Mens Singles Pro Main Draw",
      "dateOfActivity": "2026-09-01T08:30:00Z",
      "opponentNames": ["Tyson McGuffin"],
      "teamGameScores": [
        { "game": 1, "playerScore": 11, "opponentScore": 2 },
        { "game": 2, "playerScore": 11, "opponentScore": 9 }
      ],
      "matchResult": "W"
    }
  ]
}
```

When `includePlayerMatchHistory` is `false` (the default), `recentResults` is `null`.

#### Field reference

| Field | Description |
|---|---|
| `rank` | Position in the requested ranking. When `gender` is `all`, ranks are recomputed by sorting the combined men's + women's lists by points |
| `playerFullName`, `playerSlug`, `playerUuid` | Player identity; `playerSlug` is the pickleball.com profile slug |
| `countryAbbreviation` | 3-letter country code |
| `age`, `gender` | Player profile basics (`age` is `null` if pickleball.com doesn't report it) |
| `division` | The division requested (`singles`, `doubles`, or `mixed-doubles`) |
| `totalEventsPlayed` | Career events played, specific to this division |
| `points`, `livePoints`, `livePointsChange`, `liveRankingChange` | Ranking points and live movement as shown on pickleball.com |
| `profileImageUrl` | Player headshot |
| `scrapedAt` | UTC timestamp this row was fetched |
| `recentResults[].eventTitle`, `.activityTitle` | Tournament name and bracket/draw name |
| `recentResults[].dateOfActivity` | Match date/time (UTC) |
| `recentResults[].opponentNames` | Opposing team's player name(s) — one for singles, up to two for doubles/mixed |
| `recentResults[].teamGameScores` | Per-game score, from this player's perspective (`playerScore` vs `opponentScore`), one entry per game actually played |
| `recentResults[].matchResult` | `W` or `L` from this player's perspective |

### FAQ, disclaimers, and support

**Is this legal?** Yes. All data comes from pages pickleball.com serves publicly to any visitor, with no login required, and the site's `robots.txt` allows crawling. This actor reads the same server-rendered HTML a browser receives — no scraping of private data, no bypassing of authentication.

**Why is `maxPlayers` capped at 100?** pickleball.com's rankings pages only embed the top 100 rows per division/gender; no working pagination parameter was found (guessed API/sitemap paths were blocked by the site's CDN). 100 covers the entire pro tour roster for any division.

**Why does `rank` sometimes not match pickleball.com's own site for `gender: "all"`?** pickleball.com ranks men and women separately (there's no single combined list on the site). When you request `all`, this actor fetches both lists and re-sorts them together by points so you get one combined ranking; per-gender rank order is unaffected.

**How fresh is the data?** As fresh as pickleball.com itself — this actor does not cache anything; every run is a live fetch.

**Why did my run return fewer than `maxPlayers` items?** Only up to 100 rows exist per division/gender combination; requesting more than the tour's actual roster size returns however many are ranked.

#### Legal & compliance note

Only public professional-athlete performance data is collected (rankings, points, and match results that pickleball.com publishes for any site visitor) — no personal or login-walled data. DUPR (the separate amateur/personal rating platform) is explicitly out of scope; its API requires an auth key and was not accessed by this actor.

#### Limits & notes

- Only pickleball.com's own numeric ranking categories are used; if the site restructures its rankings page (chunk/prop key names), the parser may need updating.
- `recentResults` reflects whatever pickleball.com's player profile page currently shows (typically recent tournaments); it is not a complete career history.
- Requests use a realistic browser `User-Agent` and are paced modestly out of courtesy to the site.

#### Support

Found a bug or have a feature request? Use the **Issues** tab on this actor's page. For programmatic access, see the **API** tab for ready-made code snippets in your language of choice.

# Actor input Schema

## `division` (type: `string`):

Which pro ranking to pull.

## `gender` (type: `string`):

Filter the ranking by gender, or pull both.

## `maxPlayers` (type: `integer`):

How many ranking rows to pull. pickleball.com only publishes the top 100 per ranking, so this is capped at 100.

## `includePlayerMatchHistory` (type: `boolean`):

Also fetch each ranked player's profile page and attach their recent tournament-by-tournament match results (scores, opponents, dates). Makes one extra request per player, so a run with many players takes longer.

## Actor input object example

```json
{
  "division": "doubles",
  "gender": "all",
  "maxPlayers": 100,
  "includePlayerMatchHistory": false
}
```

# Actor output Schema

## `dataset` (type: `string`):

One item per ranked player

# 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("bareezh_codes/pickleball-pro-rankings-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("bareezh_codes/pickleball-pro-rankings-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 '{}' |
apify call bareezh_codes/pickleball-pro-rankings-results-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,bareezh_codes/pickleball-pro-rankings-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/RHL2HCasKntY9lboL/builds/jFO6eVKpirMNiGnDa/openapi.json