# Bassmaster Tournament Results Scraper (`automation-lab/bassmaster-tournament-leaderboards`) Actor

Export completed Bassmaster tournament leaderboards with event details, angler ranks, catch weights, and published winnings.

- **URL**: https://apify.com/automation-lab/bassmaster-tournament-leaderboards.md
- **Developed by:** [Automation Lab](https://apify.com/automation-lab) (community)
- **Categories:** Sports
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.23 / 1,000 item extracteds

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

## Bassmaster Tournament Results Scraper

Export completed **Bassmaster tournament results** as structured, analysis-ready leaderboard rows. Select events by official URL, Bassmaster scoring-system ID, or year and series; receive event metadata, final angler rank, identity, fish count, catch weight, and published winnings in the default Apify dataset.

The Actor reads Bassmaster's public event and results endpoints directly. It does not require a login, browser, or proxy.

### What can you do with this Actor?

- Export a completed tournament leaderboard to JSON, CSV, Excel, or XML.
- Build a historical table of angler finishes and catch weights.
- Track results for the Classic, Elite, Opens, College, Kayak, or another named series.
- Join stable tournament and angler IDs into a sports data warehouse.
- Schedule recurring runs and compare newly published or corrected results.
- Feed official source links and retrieval timestamps into an auditable reporting workflow.

Each dataset item represents one final angler or team placing in one tournament. Event data is repeated on each row so a downloaded table is immediately useful without a second join.

### Who is this for?

**Sports data analysts** can compare finishes, weights, and payouts across events.

**Fishing publishers and journalists** can create tables and verify figures against an official source URL.

**Fantasy and statistics developers** can ingest stable tournament IDs, angler IDs, ranks, and normalized weights.

**Automation teams** can schedule yearly or series-specific exports without maintaining a custom WordPress/API integration.

This Actor is designed for completed official results. It is not a live Basstrakk tracker, prediction service, or video collector.

### Why use this Bassmaster results scraper?

The result joins two public Bassmaster data surfaces. Final-results rows provide placing and published payout fields; leaderboard rows add fish count, hometown, and catch-weight detail. The Actor normalizes both into one typed record and preserves nulls when Bassmaster does not publish a value.

Useful safeguards include:

1. strict Bassmaster URL validation;
2. bounded request timeouts and transient retries;
3. completed-event filtering for year discovery;
4. deduplication by tournament ID;
5. global event and item limits;
6. charging only for rows that are accepted for output.

### What data is extracted?

| Field | Meaning |
| --- | --- |
| `tournamentId` | Bassmaster scoring-system tournament ID |
| `wordpressId` | Official event-page ID, when resolved from a page or search |
| `eventName` | Published tournament title |
| `eventStartDate`, `eventEndDate` | Event dates with source timezone |
| `city`, `state` | Published host location |
| `bodyOfWater` | Published competition water |
| `series` | Series text inferred from the official event slug |
| `rank` | Final placing |
| `anglerId` | Bassmaster competitor ID |
| `anglerName` | Published angler or team name |
| `hometown` | Published hometown |
| `fishCount` | Accumulated fish count |
| `totalWeightOunces` | Final weight normalized to ounces |
| `totalWeight` | Bassmaster pounds-ounces display value |
| `prizeMoneyUsd` | Published prize money |
| `cashBonusUsd` | Published cash bonus |
| `merchandiseBonusUsd` | Published merchandise bonus value |
| `totalWinningsUsd` | Published combined winnings |
| `sourceUrl` | Official event page or API URL |
| `retrievedAt` | ISO 8601 extraction timestamp |

Money fields remain `null` when the source does not publish them. A numeric zero means the source returned zero.

### How to get started

1. Open the Actor input page.
2. Keep the prefilled 2025 Bassmaster Classic URL for a first run, or replace it with another official tournament URL.
3. Set **Maximum tournaments** and **Maximum leaderboard rows**.
4. Click **Start**.
5. Open the **Dataset** tab and choose the Tournament leaderboard view.
6. Download the rows or connect the dataset to your integration.

A small URL-based run is the fastest way to verify the output contract before scheduling a larger year export.

### Input options

#### Tournament URLs

`tournamentUrls` accepts official URLs under `bassmaster.com/tournament/`. Event, results, or leaderboard variants resolve to the parent event slug.

```json
{
  "tournamentUrls": [
    "https://www.bassmaster.com/tournament/2025-bassmaster-classic/"
  ],
  "maxEvents": 1,
  "maxItems": 100
}
```

#### Tournament IDs

`tournamentIds` accepts Bassmaster scoring-system IDs. This route is useful when your database already contains source IDs. Event-page metadata is `null` because an ID alone does not identify a unique WordPress event page.

```json
{
  "tournamentIds": [1573],
  "maxItems": 25
}
```

#### Year and series discovery

Set `year` to discover completed events whose official start date is in that year. Add `series` for a case-insensitive event-title filter.

```json
{
  "year": 2025,
  "series": "elite",
  "maxEvents": 3,
  "maxItems": 200
}
```

Common series text includes `classic`, `elite`, `opens`, `college`, `kayak`, and `high school`. Matching is literal text, not a guaranteed taxonomy.

#### Limits

- `maxEvents`: 1–50, default 3.
- `maxItems`: 1–10,000, default 500.
- The item limit applies across all tournaments.
- URL, ID, and discovery inputs can be combined; duplicate IDs are processed once.

At least one URL, ID, or year is required.

### Output example

A real row from the completed 2025 Bassmaster Classic has this shape:

```json
{
  "tournamentId": 1573,
  "wordpressId": 1173856,
  "eventName": "2025 Bass Pro Shops Bassmaster Classic presented by Under Armour",
  "eventStartDate": "2025-03-21T00:00:00-05:00",
  "eventEndDate": "2025-03-23T23:59:59-05:00",
  "city": "Fort Worth",
  "state": "TX",
  "bodyOfWater": "Lake Ray Roberts",
  "series": "classic",
  "rank": 1,
  "anglerId": 75191,
  "anglerName": "Easton Fothergill",
  "hometown": "Grand Rapids , MN",
  "fishCount": 15,
  "totalWeightOunces": 1231,
  "totalWeight": "76-15",
  "prizeMoneyUsd": 300000,
  "cashBonusUsd": 8000,
  "merchandiseBonusUsd": 0,
  "totalWinningsUsd": 308000,
  "sourceUrl": "https://www.bassmaster.com/tournament/2025-bassmaster-classic/",
  "retrievedAt": "2026-09-19T14:34:54.029Z"
}
```

The default dataset view is suitable for spreadsheet export. Raw dataset items retain every documented field even when the compact table view hides some columns.

### How much does it cost to export Bassmaster tournament results?

The Actor uses pay-per-event pricing:

- one **Start** charge per run;
- one **Item processed** charge for each leaderboard row saved.

The Start price is **$0.015 per run**. The item curve is:

| Apify tier | Price per saved leaderboard row |
| --- | ---: |
| FREE | $0.000437 |
| BRONZE | $0.00038 |
| SILVER | $0.0002964 |
| GOLD | $0.000228 |
| PLATINUM | $0.000228 |
| DIAMOND | $0.000228 |

Failed, rejected, or duplicate source rows are not charged as items. The active prices also appear on the Actor's Apify pricing tab before a run starts.

As a planning formula:

`run price = $0.015 + (saved leaderboard rows × your tier's Item extracted price)`

At BRONZE, a 25-row test costs **$0.0245** and a 200-row multi-event export costs **$0.091**. Runtime usage is included in pay-per-event pricing.

### Scheduling and monitoring workflow

Create an Apify schedule with a year and series filter, then send each run's dataset to Google Sheets, a webhook, cloud storage, or your warehouse. Keep `tournamentId`, `anglerId`, `rank`, `totalWeightOunces`, `totalWinningsUsd`, and `retrievedAt` as comparison columns.

Bassmaster may correct results after an event. For change monitoring, upsert on `(tournamentId, anglerId)` and compare the remaining values rather than appending every scheduled snapshot as a new athlete.

### Export and integration patterns

#### Spreadsheet reporting

Run one or several event URLs, open Dataset, and export CSV or Excel. Sort by `tournamentId` and `rank`.

#### Sports data warehouse

Use `tournamentId` as the event key and `anglerId` as the participant key. Retain source URL and retrieval time for provenance.

#### Webhook pipeline

Configure an Apify webhook for successful runs. Read the default dataset through `defaultDatasetId` in the run payload.

#### Make, Zapier, and n8n

Trigger this Actor through the Apify integration, then map dataset rows to a sheet, database, CMS, or notification step.

### Run with the Apify API

Replace `YOUR_TOKEN` with an Apify API token.

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~bassmaster-tournament-leaderboards/runs?token=YOUR_TOKEN&waitForFinish=120" \
  -H "Content-Type: application/json" \
  -d '{"year":2025,"series":"elite","maxEvents":3,"maxItems":200}'
```

#### JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/bassmaster-tournament-leaderboards').call({
  tournamentUrls: ['https://www.bassmaster.com/tournament/2025-bassmaster-classic/'],
  maxEvents: 1,
  maxItems: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("automation-lab/bassmaster-tournament-leaderboards").call(
    run_input={"tournamentIds": [1573], "maxItems": 25}
)
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

### Use with MCP and AI agents

Add this Actor to Claude Code:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/bassmaster-tournament-leaderboards"
```

#### Claude Desktop, Cursor, and VS Code setup

Claude Desktop, Cursor, and VS Code clients that support remote MCP servers can use:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/bassmaster-tournament-leaderboards"
    }
  }
}
```

Example prompts:

- “Export the completed 2025 Bassmaster Classic leaderboard and summarize the top ten weights.”
- “Collect three completed 2025 Elite events and compare winners by total ounces.”
- “Run tournament ID 1573 with a 25-row limit and return the dataset URL.”

### Reliability and failure behavior

Requests have a 30-second timeout and up to three attempts for transient upstream failures. Events are processed sequentially to avoid unnecessary pressure on Bassmaster. Deterministic input and client errors fail immediately.

The run fails rather than silently returning malformed records when a required endpoint changes shape. A valid search with no completed matches succeeds with an empty dataset and an explanatory log message.

### Limitations

- Only public Bassmaster data is supported.
- Year discovery depends on official event titles and metadata.
- `series` is a text filter, not an exhaustive controlled list.
- Direct tournament IDs do not include event-page metadata.
- Winnings fields can be null or zero according to the source.
- This Actor exports final standings, not live catches or predictions.
- Bassmaster's public endpoints are undocumented and can change.
- The Actor does not enrich anglers with private contact information.

### Legality and responsible use

Bassmaster owns its site content and trademarks. Use exported public facts responsibly, follow applicable terms and laws, and avoid republishing protected editorial or media assets. The Actor does not bypass authentication or access private data.

When publishing a derived leaderboard, preserve source attribution and retrieval time. Review whether your use requires additional rights for commercial redistribution.

### Troubleshooting

#### “Provide at least one tournament URL, ID, or year”

Add `tournamentUrls`, `tournamentIds`, or `year`. The Actor intentionally has no unbounded “scrape everything” mode.

#### An official URL reports no results-enabled tournament

Use the parent event URL under `/tournament/<event-slug>/`. Confirm that the event publishes a nonzero results/scoring ID and has completed results.

#### A year and series returns no rows

Try the year without `series`, then inspect official titles and use a shorter exact fragment. Future or incomplete events are excluded.

#### Some payout or event fields are null

Null means the selected input route or Bassmaster source did not publish that value. Use an event URL or year discovery rather than ID-only input when event metadata is required.

#### The dataset stops partway through an event

Increase `maxItems`. The limit is global across all selected tournaments and is applied in rank order.

### FAQ

#### Does it support the Bassmaster Classic?

Yes. Supply the official Classic event URL, scoring ID, or a year plus a sufficiently specific Classic title fragment.

#### Can I collect multiple tournaments in one run?

Yes. Combine URLs and IDs or use year discovery, then set `maxEvents` and `maxItems` for the required scope.

#### Are weights numeric?

Both forms are included: `totalWeightOunces` is numeric and `totalWeight` preserves Bassmaster's pounds-ounces display.

#### Are results live?

No. This product is intentionally optimized for completed final standings. The retrieval timestamp identifies when the snapshot was collected.

#### Do I need a proxy?

No. The Actor uses public JSON endpoints directly and has no automatic proxy fallback.

#### Can I schedule it?

Yes. Use Apify schedules and downstream integrations. Upsert stable IDs when you want change monitoring instead of duplicate snapshots.

### Related Automation Lab Actors

For broader sports data work, see the [NCAA College Sports Schedules & Scores API](https://apify.com/automation-lab/ncaa-college-sports-data-api). It covers official NCAA games rather than fishing tournament leaderboards.

For event discovery rather than sports results, see the [Ticketmaster Events Scraper](https://apify.com/automation-lab/ticketmaster-events-scraper).

These are complementary workflows; neither is a substitute for Bassmaster's per-angler final standings.

# Changelog

This Actor's version history is a separate document: https://apify.com/automation-lab/bassmaster-tournament-leaderboards/changelog.md

# Actor input Schema

## `tournamentUrls` (type: `array`):

Official bassmaster.com tournament, results, or leaderboard URLs. The Actor resolves each URL to its public results ID.

## `tournamentIds` (type: `array`):

Bassmaster scoring-system tournament IDs, for example 1573 for the 2025 Bassmaster Classic. Useful for data pipelines that already store IDs.

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

Discover completed tournament event pages whose event start date falls in this year. May be combined with Series filter.

## `series` (type: `string`):

Optional case-insensitive text matched against event titles, such as classic, elite, opens, college, kayak, or high school.

## `maxEvents` (type: `integer`):

Maximum number of distinct completed tournaments to process after URL, ID, year, and series selection are combined.

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

Maximum angler rows saved across all selected tournaments.

## Actor input object example

```json
{
  "tournamentUrls": [
    "https://www.bassmaster.com/tournament/2025-bassmaster-classic/"
  ],
  "maxEvents": 1,
  "maxItems": 20
}
```

# Actor output Schema

## `overview` (type: `string`):

Open the default dataset in the typed tournament leaderboard view.

# 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 = {
    "tournamentUrls": [
        "https://www.bassmaster.com/tournament/2025-bassmaster-classic/"
    ],
    "maxEvents": 1,
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/bassmaster-tournament-leaderboards").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 = {
    "tournamentUrls": ["https://www.bassmaster.com/tournament/2025-bassmaster-classic/"],
    "maxEvents": 1,
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/bassmaster-tournament-leaderboards").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 '{
  "tournamentUrls": [
    "https://www.bassmaster.com/tournament/2025-bassmaster-classic/"
  ],
  "maxEvents": 1,
  "maxItems": 20
}' |
apify call automation-lab/bassmaster-tournament-leaderboards --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/bassmaster-tournament-leaderboards"
        }
    }
}
```

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/4XcmROmNbeXxIhIVd/builds/gSabKMW8RbZ1SUgVM/openapi.json