# Fanatics Collect Auction Lots Scraper (`automation-lab/fanatics-collect-auction-lots-scraper`) Actor

Extract public Fanatics Collect weekly auction lots with listing IDs, lot numbers, bids, currency, scheduled auction dates and images for collectible valuation snapshots.

- **URL**: https://apify.com/automation-lab/fanatics-collect-auction-lots-scraper.md
- **Developed by:** [Automation Lab](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.68 / 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

## Fanatics Collect Auction Lots Scraper

Extract public **Fanatics Collect auction lots** from the weekly marketplace as structured snapshots. Get listing and auction IDs, lot numbers, titles, displayed current bids, currency, bid counts, scheduled auction dates and images without logging in.

For collectible dealers, card-market analysts and spreadsheet users who need repeatable weekly inventory and valuation inputs. This Actor reads public cards; it never bids, buys or accesses an account.

### Who is it for?

Collectible dealers refresh weekly auction inventory; analysts compare displayed bid snapshots; spreadsheet users review lots without manual copying.

### Why use this Actor?

- Join snapshots by listing UUID instead of matching changing titles.
- Keep displayed bids separate from final-sale prices.
- Preserve auction identity and lot-number suffixes.
- Export clean rows to JSON, CSV, Excel or your own data pipeline through Apify datasets.
- Stop at your chosen global lot/page limits without charging duplicate lots.

### What can I scrape?

The public weekly auction marketplace at `https://www.fanaticscollect.com/marketplace?type=WEEKLY`.

The current marketplace determines which auctions and lots appear. No fixed auction number is hardcoded. The Actor follows consecutive search pages, currently observed at 48 lots per page, with a maximum page index of 50. This is a bounded marketplace snapshot, not a complete historical archive.

Premier auctions, Buy Now, sold history, individual detail descriptions, certification enrichment, watchlists, bidding and alerts are not supported. Do not infer those capabilities from the general Fanatics Collect brand.

### Getting started

1. Open this Actor in Apify Console.
2. Keep the weekly marketplace URL or add a supported starting `page`.
3. Set `maxItems` and `maxPages`.
4. Start the Actor and inspect its default dataset.
5. Export the rows or connect the dataset to your downstream workflow.

```json
{
  "startUrl": "https://www.fanaticscollect.com/marketplace?type=WEEKLY",
  "maxItems": 100,
  "maxPages": 3
}
```

### Input parameters

| Field | Default | Meaning |
| --- | --- | --- |
| `startUrl` | Weekly marketplace, page 1 | HTTPS www.fanaticscollect.com marketplace URL with `type=WEEKLY` and optional `page=1–50` |
| `maxItems` | 100 | Global maximum unique weekly lots saved, 1–2400 |
| `maxPages` | 3 | Consecutive pages visited, 1–50; starting page plus this limit cannot exceed page 50 |

Only `type` and `page` URL parameters are accepted. Other filters and unsupported URL routes fail validation rather than being silently ignored. Zero/unlimited limits are not supported. No user account or proxy credential is required; no proxy fallback is enabled.

### Pagination and coverage

Collection stops at the first of the lot limit, page limit or visible last page. The upstream search can cap results, and its page size/order can change. Lots appearing on multiple pages are deduplicated by listing ID within each run. Separate runs intentionally return new snapshots of the same lots.

Large 50-page runs can take substantially longer in the cloud than locally. The default platform timeout is one hour; lower user timeouts may leave a failed partial snapshot. Billing limits can stop delivery earlier.

Changing bids and inventory during collection can shift search order. This Actor does not promise an atomic snapshot or exhaustive coverage of all source inventory.

### Output fields

| Field | Meaning |
| --- | --- |
| `listingId` | Public listing UUID used for joins |
| `auctionId`, `auctionName` | Weekly auction identity |
| `lotNumber` | Source lot number including suffixes; null when the source omits it |
| `title` | Displayed card title |
| `subtitle` | Displayed grading/population text, or null |
| `url` | Canonical public weekly lot URL |
| `currentBid`, `currency` | Current displayed bid in currency units |
| `bidCount` | Displayed number of bids |
| `auctionStatus`, `listingStatus` | Source auction/listing status |
| `auctionStartsAt`, `auctionEndsAt` | Scheduled auction timing in UTC |
| `images` | Public source image URLs, not downloaded files |
| `scrapedAt` | UTC observation timestamp |

The default dataset contains one row per unique listing. A `SUMMARY` key-value record contains saved count and configured limits.

### Output example

This excerpt reflects an observed weekly card; volatile bid values are illustrative of that snapshot, not current quotes.

```json
{
  "listingId": "9fe1b4d0-b8d9-11f1-9aff-0a58a9feac02",
  "auctionName": "Weekly Auction #247",
  "lotNumber": "4515",
  "title": "2003 Exquisite Collection Number Piece Magic Johnson PATCH AUTO /32 #NP-MA PSA 7 NRMT",
  "currentBid": 74,
  "currency": "USD",
  "bidCount": 11,
  "auctionEndsAt": "2026-10-12T02:00:00Z"
}
```

The actual row also includes the fields documented above. A displayed current bid is not a hammer price, valuation recommendation or completed sale.

### How much does it cost to extract Fanatics Collect auction lots?

Pay per event: a one-time **$0.005 start fee**, plus a tier-dependent charge for each unique saved lot. The BRONZE rate is **$0.0028 per lot**; consult the Actor's live Pricing tab for the active tier prices.

At that BRONZE rate, 10 lots cost $0.033, 100 cost $0.285 and 1,000 cost $2.805. Start is charged once after input validation. Duplicate or rejected lots have no item charge. A failed run can still incur its start fee and charges for already saved partial rows. Your maximum charge/run settings can also limit delivery.

### Timing and limitations

`auctionEndsAt` is the scheduled close / beginning of extended bidding from the public auction metadata. It is not a guarantee of the final bidding deadline for an individual lot. Use the source website for bidding decisions.

No item detail page is visited. Images remain external URLs and may change or expire. Population text is copied as displayed, not independently verified. This Actor is not affiliated with Fanatics Collect.

### Failure behavior and troubleshooting

Malformed inputs fail before work begins. Transient navigation/data failures receive at most one retry with a fresh anonymous browser context. Missing required fields, challenge pages, empty response shells or repeated pagination fail explicitly instead of claiming a successful empty snapshot.

If the source changes, retry later only after inspecting the error. Do not treat partial rows from a failed run as a complete result. An empty weekly marketplace is not currently a supported successful no-result mode.

### Integrations

- **Google Sheets / Excel:** export rows for lot review and inventory planning.
- **Database:** append snapshots keyed by listing ID and observation timestamp; compare bids across scheduled runs.
- **Apify schedules:** run periodic snapshots yourself; compare and alert in your own workflow. The Actor does not send alerts.
- **Webhooks:** trigger your pipeline after a successful run and read the default dataset.

### API usage

Use your own Apify token securely. The synchronous dataset endpoint returns rows after completion; for long jobs use asynchronous runs and follow the same run ID.

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~fanatics-collect-auction-lots-scraper/run-sync-get-dataset-items' \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"maxItems":100,"maxPages":3}'
```

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/fanatics-collect-auction-lots-scraper').call({ maxItems: 100, maxPages: 3 });
const { items } = await client.dataset(run.defaultDatasetId).listItems({ limit: 100 });
```

```python
import os
from apify_client import ApifyClient
client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/fanatics-collect-auction-lots-scraper').call(run_input={'maxItems': 100, 'maxPages': 3})
items = client.dataset(run['defaultDatasetId']).list_items(limit=100).items
```

### MCP usage

Select a stable Actor subset:

```bash
claude mcp add --transport http apify \
  'https://mcp.apify.com?tools=automation-lab/fanatics-collect-auction-lots-scraper'
```

```json
{"mcpServers":{"apify":{"type":"http","url":"https://mcp.apify.com?tools=automation-lab/fanatics-collect-auction-lots-scraper"}}}
```

Use that HTTP configuration in Claude Desktop, Cursor or VS Code with an MCP-capable client. Example prompt: “Extract 10 weekly auction lots, then show title, currentBid and bidCount.”

Discover actual tool names and schemas with scoped `tools/list`. Selection also adds run/data helper tools; discovery is not permission to execute. An example authorized request is “Collect 100 public weekly lots and show their titles and bids.”

Start once, retain the returned run ID and storage IDs. If pending, check that same run with bounded backoff (2, 4, 8 seconds capped at 10) and a total deadline such as 120 seconds. Configure the client timeout above the selected server wait plus transport margin. A timeout is not a reason to start a duplicate run. At deadline report pending with its ID; report terminal failures honestly.

After success, read bounded dataset pages of 20 source rows, at most 100 rows and 64 KiB of serialized UTF-8 content admitted to model context, whichever comes first. Enforce bytes host-side; omit/summarize oversized rows with disclosure. Track source offsets, report partial/truncated results and keep full exports outside model context. Clients without host-side interception cannot guarantee that byte ceiling. No numeric token-saving claim is made.

### Legality and diagnostics

Use public data responsibly, comply with applicable terms and laws, and avoid excessive request frequency. Do not use this dataset as an authoritative bidding or investment feed.

Failed operations send sanitized diagnostic input, exceptions and Actor/build/run IDs to our private GlitchTip service for repair. Secret fields and URL queries are removed; reports are retained for 30 days. No login or private buyer data is collected by this Actor. No AI service is used at runtime. Browser sessions are ephemeral and closed after each page; datasets, summaries and platform logs follow your Apify storage retention and deletion settings. Delete run storage through Apify when no longer needed. For assistance use the Actor's Apify Issues tab.

### FAQ

**Does it return sold prices or Premier lots?** No. This release is limited to public weekly marketplace cards.

**Can I filter by player or grade?** Not in this release. Unsupported URL filters are rejected. Filter exported snapshots in your own tools.

**Can I schedule it?** Yes, using Apify schedules. Comparison and alerts belong in your downstream system.

**Why did it return fewer than maxItems?** The page limit, visible last page, source coverage or billing limit can stop collection earlier.

**Why did it fail with zero rows?** The source may have challenged the browser or changed its public response shape. The Actor fails rather than silently delivering an empty inventory.

### Related Actors

For a separate auction-market workflow, see [Bring a Trailer Auctions & Results Scraper](https://apify.com/automation-lab/bring-a-trailer-auctions-results-scraper). It covers vehicle auctions, not Fanatics Collect cards.

# Changelog

This Actor's version history is a separate document: https://apify.com/automation-lab/fanatics-collect-auction-lots-scraper/changelog.md

# Actor input Schema

## `startUrl` (type: `string`):

Public https://www.fanaticscollect.com/marketplace?type=WEEKLY URL, optionally with page=1–50. Only type and page parameters are supported; other filters, Premier, sold history and detail URLs are rejected. Defaults to page 1 of the current weekly marketplace.

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

Global maximum unique weekly lots saved per run (1–2400, default 100). Zero/unlimited is not supported. Collection may stop earlier at maxPages or source pagination exhaustion. Duplicates are not charged.

## `maxPages` (type: `integer`):

Consecutive pages to visit from the URL page (1–50, default 3). The end page must not exceed 50. Stops sooner at maxItems or the visible last page; the source may cap search coverage. Current page size is source-controlled (observed 48 lots).

## Actor input object example

```json
{
  "startUrl": "https://www.fanaticscollect.com/marketplace?type=WEEKLY",
  "maxItems": 20,
  "maxPages": 3
}
```

# Actor output Schema

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

Unique weekly lots in the default dataset

## `summary` (type: `string`):

Saved count and configured limits

# 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 = {
    "startUrl": "https://www.fanaticscollect.com/marketplace?type=WEEKLY",
    "maxItems": 20,
    "maxPages": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/fanatics-collect-auction-lots-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 = {
    "startUrl": "https://www.fanaticscollect.com/marketplace?type=WEEKLY",
    "maxItems": 20,
    "maxPages": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/fanatics-collect-auction-lots-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 '{
  "startUrl": "https://www.fanaticscollect.com/marketplace?type=WEEKLY",
  "maxItems": 20,
  "maxPages": 3
}' |
apify call automation-lab/fanatics-collect-auction-lots-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/fanatics-collect-auction-lots-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/yRYjWpD0lOMZtoMcw/builds/BM7l3CbHUXhvAdbhI/openapi.json