# PGA Tour Leaderboard Scraper (`parseforge/pgatour-leaderboard-scraper`) Actor

Track PGA Tour leaderboards with tournament, player, position, score to par, round scores, total, country, FedEx points, prize money, and status. Filter by tournament ID and tour. Handy for golf analytics dashboards, fantasy tools, betting models, and live tournament coverage workflows.

- **URL**: https://apify.com/parseforge/pgatour-leaderboard-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** News, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $7.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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🏌️ PGA Tour Leaderboard Scraper

> 🚀 **Export PGA Tour live leaderboards in seconds. Positions, round scores, FedEx points, prize money - direct from pgatour.com.**

> 🕒 **Last updated:** 2026-05-29 · **📊 13 fields** per player · PGA, Champions, Korn Ferry, LPGA · Live and historical · Round-by-round splits

The PGA Tour Leaderboard Scraper queries the public pgatour.com GraphQL orchestrator for any tournament leaderboard. Get every player's position, round scores, total, FedEx points, and prize money in one structured dataset.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| 🏌️ Golf fans | Track your favourite players live |
| 📊 Sports analysts | Build season-long performance datasets |
| 📰 Sports journalists | Pull leaderboards for instant copy |
| 🤖 ML engineers | Train predictive golf models |
| 👩‍💻 Developers | Mirror PGA Tour data into your app |

### 📋 What the PGA Tour Leaderboard Scraper does

- Queries the pgatour.com GraphQL endpoint for any tournament.
- Auto-selects the current/most recent tournament if no ID given.
- Returns per-player position, round scores, totals, FedEx points, earnings, country.
- Includes headshot image URL.
- Exports CSV, Excel, JSON, JSONL, XML, RSS, HTML.

> 💡 **Why it matters:** PGA Tour's leaderboard updates live during play. This actor gives you a snapshot in one API call - no HTML scraping, no headless browser.

### 🎬 Full Demo

_🚧 Coming soon._

### ⚙️ Input

<table>
<tr><th>Field</th><th>Type</th><th>Required</th><th>Description</th></tr>
<tr><td><code>tournamentId</code></td><td>string</td><td>No</td><td>PGA Tour tournament ID. Auto-detected if empty.</td></tr>
<tr><td><code>tour</code></td><td>enum</td><td>No</td><td>PGA, Champions, Korn Ferry, LPGA.</td></tr>
<tr><td><code>maxItems</code></td><td>integer</td><td>No</td><td>Free 10, paid up to 1,000,000.</td></tr>
</table>

**Example 1 - auto-detect current tournament:**
```json
{ "maxItems": 10 }
````

**Example 2 - specific tournament:**

```json
{ "tournamentId": "R2025002", "maxItems": 50 }
```

> ⚠️ **Good to Know:** Leaderboards update live; rerun mid-round for latest positions.

### 📊 Output

| Field | Type | Description |
|---|---|---|
| 🖼️ `imageUrl` | string | Player headshot. |
| 🏆 `tournament` | string | Tournament name. |
| 🏌️ `player` | string | Player name. |
| 🥇 `position` | string | Leaderboard position. |
| 📉 `scoreToPar` | string | Total to par. |
| 🔢 `roundScores` | array | Round-by-round scores. |
| 📊 `total` | number | Total strokes. |
| 🌍 `country` | string | Country code. |
| 🏅 `fedexPoints` | number | FedEx Cup points earned. |
| 💰 `prizeMoney` | string | Prize money. |
| ⏱️ `status` | string | Active, cut, withdrawn. |
| 🕒 `scrapedAt` | string | Fetched at. |
| ❌ `error` | string | Set on error. |

```json
{
  "imageUrl": "https://pga-tour-res.cloudinary.com/.../headshots_30911.png",
  "tournament": "The Memorial Tournament",
  "player": "S. Scheffler",
  "position": "1",
  "scoreToPar": "-12",
  "roundScores": [68, 67, 70, 71],
  "total": 276,
  "country": "USA",
  "fedexPoints": 700,
  "prizeMoney": "$4,000,000",
  "status": "F",
  "scrapedAt": "2026-05-29T12:00:00.000Z",
  "error": null
}
```

### ✨ Why choose this Actor

| 🏌️ | Real PGA Tour GraphQL - same source as pgatour.com. |
| ⚡ | Single API call per tournament. |
| 🏅 | FedEx points and prize money included. |
| 🧹 | Clean flat schema. |
| 💾 | CSV / Excel / JSON / XML export. |

### 📈 How it compares to alternatives

| Approach | Setup | Live updates | Round splits |
|---|---|---|---|
| HTML scrape | 1+ hr | brittle | manual |
| **This Actor** | 5 sec | yes | yes |

### 🚀 How to use

1. Click **Try for free**.
2. Leave inputs blank to auto-detect the current tournament.
3. Click **Start**.

### 💼 Business use cases

**📊 Fantasy golf analytics.** Pull every weekly leaderboard for backtesting.
**📰 Newsroom.** Instant leaderboards for golf coverage.
**🏌️ Coaching.** Track student rankings.
**🤖 Modelling.** Train shot-by-shot prediction.

### 🔌 Automating PGA Tour Leaderboard Scraper

- **Make / Zapier**: poll during tournaments.
- **Cron**: Sunday-evening final results.
- **Webhooks**: instant push.
- **BigQuery**: native pipeline.

### 🌟 Beyond business use cases

**🎓 Education.** Sports statistics teaching.
**🧪 Personal.** Track your favourites.
**🤝 Non-profit.** Junior golf rankings.
**🧰 Tinkering.** Build a Discord leaderboard bot.

### 🤖 Ask an AI assistant about this scraper

Drop this README into your favourite LLM for pipeline design.

### ❓ Frequently Asked Questions

**❓ API key?** No.
**❓ Tours covered?** PGA, Champions, Korn Ferry, LPGA.
**❓ Live or final only?** Both.
**❓ Round splits?** Yes.
**❓ Format?** CSV, Excel, JSON, JSONL, XML, RSS, HTML.
**❓ Schedule?** Yes.
**❓ Rate-limited?** Reasonable use.
**❓ Schema stable?** Core fields stable.
**❓ Free tier?** 10 players preview.
**❓ Headshots?** Yes, included.

### 🔌 Integrate with any app

Make, Zapier, Slack, Discord, Drive, Sheets, Gmail, Airbyte, Keboola, Telegram, GitHub, REST/webhook.

### 🔗 Recommended Actors

| Actor | What it does |
|---|---|
| [ParseForge NBA Stats Scraper](https://apify.com/parseforge/nba-stats-scraper) | NBA stats. |
| [ParseForge OurAirports Scraper](https://apify.com/parseforge/ourairports-scraper) | Airport database. |
| [ParseForge JustWatch Scraper](https://apify.com/parseforge/justwatch-streaming-scraper) | Streaming availability. |
| [ParseForge Alpha Vantage Scraper](https://apify.com/parseforge/alpha-vantage-public-scraper) | Markets data. |

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for 900+ scrapers.

***

**Disclaimer:** This actor scrapes only publicly available data. ParseForge is not affiliated with the PGA Tour. [Create a free account w/ $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp).

# Actor input Schema

## `tournamentId` (type: `string`):

PGA Tour tournament ID (e.g. R2025002). Leave empty to scrape the current/most recent tournament.

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## `tour` (type: `string`):

Which tour leaderboard to scrape.

## Actor input object example

```json
{
  "maxItems": 10,
  "tour": "R"
}
```

# Actor output Schema

## `results` (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 = {
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/pgatour-leaderboard-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 = { "maxItems": 10 }

# Run the Actor and wait for it to finish
run = client.actor("parseforge/pgatour-leaderboard-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "maxItems": 10
}' |
apify call parseforge/pgatour-leaderboard-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=parseforge/pgatour-leaderboard-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "PGA Tour Leaderboard Scraper",
        "description": "Track PGA Tour leaderboards with tournament, player, position, score to par, round scores, total, country, FedEx points, prize money, and status. Filter by tournament ID and tour. Handy for golf analytics dashboards, fantasy tools, betting models, and live tournament coverage workflows.",
        "version": "0.1",
        "x-build-id": "TLxrx0N5Y25nSyfN0"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~pgatour-leaderboard-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-pgatour-leaderboard-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/parseforge~pgatour-leaderboard-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-pgatour-leaderboard-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/parseforge~pgatour-leaderboard-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-pgatour-leaderboard-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "tournamentId": {
                        "title": "Tournament ID",
                        "type": "string",
                        "description": "PGA Tour tournament ID (e.g. R2025002). Leave empty to scrape the current/most recent tournament."
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "tour": {
                        "title": "Tour",
                        "enum": [
                            "R",
                            "S",
                            "H",
                            "LPGA"
                        ],
                        "type": "string",
                        "description": "Which tour leaderboard to scrape.",
                        "default": "R"
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```