# Golf & PGA Data — Tournaments, Leaderboards & Scores (`foxlabs/golf-pga-data`) Actor

Golf leaderboards as clean rows: every tournament in a date range with its full field — player, finishing position, total score, round-by-round scores and status. PGA, LPGA, Champions, Korn Ferry and European Tour. No API key, no login.

- **URL**: https://apify.com/foxlabs/golf-pga-data.md
- **Developed by:** [Berkan Kaplan](https://apify.com/foxlabs) (community)
- **Categories:** Sports, News
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$1.50 / 1,000 leaderboard rows

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## Golf & PGA Data Scraper — Leaderboards, Rounds & Hole-by-Hole Scores ⛳

**foXLabs sports data:** Golf · (UFC/MMA · Formula 1 · Cricket · Rugby — the same family)

🎉 Turn golf into clean, structured data: every tournament's full leaderboard with **round-by-round scores** (strokes and to-par) and, on request, **hole-by-hole scores** for each round. PGA, LPGA, Champions, Korn Ferry and the European (DP World) Tour. No API key, no login. Built for DFS and betting modellers, media and stats products, and AI agents.

### 🔍 What is the Golf Data Scraper — and when should you use it?

Give a tour and a date range and get one row per player per tournament: finishing position, total score, each round's strokes and to-par, and optionally the 18 hole scores of every round.

**Use it when you need:** a DFS or betting model (round form, hole-level scoring); a leaderboard widget; or historical tournament data. **Use something else when** you want other sports — see the rest of the foXLabs sports family.

Note: this covers **scores**, not proprietary shot-tracking metrics (strokes-gained is not published in the free source).

### 🤖 Use with AI agents

**Already on the Apify MCP server?** Ask for it by name: `foxlabs/golf-pga-data`.

**Your agent can pay for its own runs** — pay-per-event with agentic payments over **x402 (USDC on Base)** or **Skyfire**, with no Apify account of its own. Billing is per delivered row, never for errors or empty results.

Paste into Claude, ChatGPT, Cursor or any MCP assistant:

```
Use the Apify Actor `foxlabs/golf-pga-data`.
Input: `tour` = pga | lpga | champions | korn | euro; `dateFrom`/`dateTo` (YYYY-MM-DD);
`includeHoleScores` adds the 18 hole scores per round; `maxResults` caps rows.
Start with: { "tour": "pga", "dateFrom": "2024-04-11", "dateTo": "2024-04-14" }
```

**Things you can ask your agent:**

- "Give me the full leaderboard of the last PGA tournament with each player's four round scores."
- "Add the hole-by-hole scores for the leaders."
- "Which players shot under par in round 3?"

### 📋 Overview

The Golf Data Scraper reads ESPN's public, keyless golf API live on every run and returns deduplicated, camelCase rows. There is nothing to configure: no key, no login, no proxy to buy (Apify's free datacenter proxy is used by default).

**Why teams pick this actor:**

- 🧱 **Five tours, one actor** — PGA, LPGA, Champions, Korn Ferry, European.
- 🕳️ **Hole-level scoring that leaderboard scrapers skip** — every hole of every round, on request.
- 🔑 **Zero setup** — no API key, no login, no browser.
- ♻️ **Fresh every run** — reads the source live.
- 🤝 **Agent-ready** — MCP + x402, billed per delivered row.

### ✨ Features

- 🏌️ **Full leaderboard** — player, position, total score and status.
- 🔢 **Round-by-round** — strokes and to-par for each round.
- 🕳️ **Hole-by-hole** — the 18 hole scores (strokes and to-par) per round, with `includeHoleScores`.
- 🌍 **Five tours** — PGA, LPGA, Champions, Korn Ferry, European.
- 📦 **Clean export** — deduplicated camelCase rows, ready for CSV/Excel/JSON.

### 🎬 Quick Start

```bash
curl -X POST "https://api.apify.com/v2/acts/foxlabs~golf-pga-data/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"tour": "pga", "dateFrom": "2024-04-11", "dateTo": "2024-04-14"}'
```

### 🚀 Getting Started (3 steps)

1. **Pick a tour** — `pga`, `lpga`, `champions`, `korn` or `euro`.
2. **Set the dates** — `dateFrom`/`dateTo` (defaults: last 21 / next 21 days); turn on `includeHoleScores` for hole detail.
3. **Run and export** — download the dataset as JSON, CSV or Excel, or pull it from the API.

### 📥 Input

```json
{
  "tour": "pga",
  "dateFrom": "2024-04-11",
  "dateTo": "2024-04-14",
  "includeHoleScores": false,
  "maxResults": 0
}
```

| Field | Type | Description |
|---|---|---|
| `tour` | string | `pga` (default), `lpga`, `champions`, `korn`, `euro`. |
| `dateFrom` / `dateTo` | string | Tournament date range (YYYY-MM-DD). Defaults: last 21 / next 21 days. |
| `includeHoleScores` | boolean | Add the 18 hole scores per round (default off). |
| `maxResults` | integer | Cap on delivered rows (0 = default). |
| `proxyConfiguration` | object | Apify datacenter by default — no setup needed. |

### 📤 Output

**Leaderboard row** (with `includeHoleScores`, `holes` is added inside each round):

```json
{
  "tournamentId": "401580351", "tournament": "Masters Tournament", "tour": "pga",
  "date": "2024-04-11T07:00Z", "endDate": "2024-04-14T07:00Z", "status": "Final",
  "position": 1, "player": "Scottie Scheffler", "playerId": "9478", "country": "United States",
  "totalScore": "-11",
  "rounds": [
    { "round": 1, "strokes": 66, "toPar": "-6", "holes": [{ "hole": 1, "strokes": 4, "result": "E" }, { "hole": 2, "strokes": 4, "result": "-1" }] },
    { "round": 2, "strokes": 72, "toPar": "E" }
  ],
  "playerStatus": "Final", "source": "ESPN", "scrapedAt": "2026-11-02T11:00:00.000Z"
}
```

| Field | Type | Description |
|---|---|---|
| `tournament` / `tournamentId` | string | Event name and ESPN id. |
| `date` / `endDate` / `status` | string | Tournament dates and status. |
| `position` | number | Finishing position. |
| `player` / `playerId` / `country` | string | Player identity. |
| `totalScore` | string | Total to-par (e.g. `-11`). |
| `rounds` | array | Per round: `round`, `strokes`, `toPar`, and `holes` (when requested). |
| `playerStatus` / `amateur` | string / bool | Player's status; amateur flag. |

### 💼 Use cases

- **DFS / betting model**
  - *Input:* `{ "tour": "pga", "includeHoleScores": true }`
  - *Output:* every player with round and hole scores.
  - *Use:* model round form, hole difficulty and scoring streaks.
- **Leaderboard widget**
  - *Input:* `{ "tour": "pga" }`
  - *Output:* the live leaderboard with round scores.
- **Historical analysis**
  - *Input:* `{ "tour": "pga", "dateFrom": "2024-01-01", "dateTo": "2024-12-31" }`
  - *Output:* a season of tournaments.

### 🔗 Integration

**JavaScript (Apify client):**

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('foxlabs/golf-pga-data').call({ tour: 'pga', includeHoleScores: true });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

**Python (Apify client):**

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_TOKEN")
run = client.actor("foxlabs/golf-pga-data").call(run_input={"tour": "pga", "includeHoleScores": True})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

**n8n / Zapier / Make:** use the Apify connector, pick this actor, map `tour` and the dates, then route the dataset into your sheet, database or webhook.

### 📊 Pricing

**Pay per result (PPE).** You are billed only for delivered leaderboard rows, never for errors or empty runs. Current prices are on the Pricing tab.

### ❓ FAQ

#### Do I need an API key or a login to scrape golf data?

No. You supply nothing: pick a tour and a date range and run. There is no golf API key to obtain, no account to connect and no browser to configure. The actor reads ESPN's public golf API directly through Apify's free datacenter proxy.

#### Which tours and tournaments does it cover?

Five tours: the PGA Tour, LPGA, PGA Tour Champions, Korn Ferry Tour and the European (DP World) Tour. For each tour it returns every tournament whose dates fall in your range, with the full field — not just the top of the leaderboard.

#### What does each leaderboard row contain?

One row per player per tournament: finishing position, total score to par, status (e.g. Final, cut, WD), and a `rounds` array giving each round's strokes and to-par. With `includeHoleScores` on, every round also carries its 18 hole scores.

#### How do I get hole-by-hole scores?

Turn on `includeHoleScores`. Each round then carries its 18 hole scores, each with the strokes taken and the result relative to par (E for par, -1 for a birdie, +1 for a bogey, and so on).

#### Do you have strokes-gained or shot-tracking data?

No. The free source publishes scores at the round and hole level, not proprietary shot-tracking metrics such as strokes-gained, driving distance or putts-gained, which come from the tours' own ShotLink-style systems. If a vendor claims free strokes-gained, check the source.

#### How current is the data during a tournament?

Every run reads ESPN live, so positions and round scores update through the tournament as ESPN posts them. Mid-round, a player's current round shows the holes played so far; completed rounds are final.

#### How is this different from a generic leaderboard scraper?

A generic scraper stops at position and total score. This actor adds the layer golf modellers and DFS players use: each round's strokes and to-par, and, on request, the full hole-by-hole card for every player in the field.

#### Can I pull a whole season or just one tournament?

Both. A narrow `dateFrom`/`dateTo` returns a single event; a wide range (for example a full calendar year) returns every tournament of the season on that tour.

#### How are cuts, withdrawals and ties handled?

The `playerStatus` field reflects what ESPN shows — made cut, missed cut, withdrawn or disqualified — and `position` reflects ties as ESPN ranks them. Amateurs are flagged with `amateur: true`.

#### Can I export to CSV, Excel or JSON?

Yes. Download the dataset as JSON, CSV or Excel from the Apify console, or pull it straight from the Apify API or the dataset's `.json` endpoint for a pipeline or an AI agent.

### 🐛 Troubleshooting

- **No tournaments found** — widen `dateFrom`/`dateTo`; golf has off-season weeks with no events.
- **A round has no holes** — holes appear only with `includeHoleScores`, and only for rounds that have been played.
- **Fewer rows than `maxResults`** — `maxResults` is a cap, not a target.

### ⚠️ Trademark

Independent, third-party tool. Not affiliated with, endorsed by or connected to the PGA Tour, LPGA, the European Tour or ESPN. All marks belong to their owners and are used for identification only.

### ⚖️ Is it legal to scrape this data?

This actor reads publicly available, non-personal sports data (tournament scores and standings) that is already published for public viewing. It collects no private or personal data and requires no login. You are responsible for using the output in line with applicable laws and the terms of the sources. When in doubt, consult a lawyer.

### 🤝 Support & contact

- 🌐 **Website:** [data.foxlabs.com.tr](https://data.foxlabs.com.tr)
- 📧 **Email:** info@foxlabs.com.tr
- 🧰 **More clean data actors:** [Fox Labs on Apify](https://apify.com/foxlabs)

### Changelog

#### 0.2 — 2026-11-02

- Round scores are now structured (`rounds` with `round`, `strokes`, `toPar`), and a new `includeHoleScores` option adds the 18 hole scores (strokes and to-par) for each round.

#### 0.1 — 2026-11-02

- Initial release: leaderboards with flat round scores across five tours from ESPN's keyless API.

# Changelog

This Actor's version history is a separate document: https://apify.com/foxlabs/golf-pga-data/changelog.md

# Actor input Schema

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

Which tour's tournaments to pull.

## `dateFrom` (type: `string`):

Earliest tournament date. Defaults to 21 days ago.

## `dateTo` (type: `string`):

Latest tournament date. Defaults to 21 days ahead.

## `includeHoleScores` (type: `boolean`):

Add the 18 hole scores (strokes and to-par) for each round of each player. Off by default; makes each row larger.

## `maxResults` (type: `integer`):

Cap on delivered leaderboard rows (0 = default).

## `proxyConfiguration` (type: `object`):

Leave it on. The Actor reaches ESPN through Apify's free datacenter proxy; no setup is needed. You may switch to residential or your own proxy if you prefer.

## Actor input object example

```json
{
  "tour": "pga",
  "includeHoleScores": false,
  "maxResults": 200,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

No description

## `report` (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 = {
    "tour": "pga",
    "maxResults": 200,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("foxlabs/golf-pga-data").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 = {
    "tour": "pga",
    "maxResults": 200,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("foxlabs/golf-pga-data").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 '{
  "tour": "pga",
  "maxResults": 200,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call foxlabs/golf-pga-data --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,foxlabs/golf-pga-data"
        }
    }
}
```

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/aEv3Web0vYTWQ9xMg/builds/zKZJgzkPkFcMJn8Mj/openapi.json