# PriceCharting Collection Scraper (`incognito_mode/pricecharting-collection-scraper`) Actor

Scrape an entire PriceCharting collection/console page (e.g. a full Pokemon set or game console) in one record: the collection's historical value and median-price time series, plus every product in the set with its name, ID, image and listed prices. Failed lookups are never billed.

- **URL**: https://apify.com/incognito\_mode/pricecharting-collection-scraper.md
- **Developed by:** [Elena Vance](https://apify.com/incognito_mode) (community)
- **Categories:** E-commerce, Integrations, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $250.00 / 1,000 collection results

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/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

## PriceCharting Collection Scraper — Whole-Set Prices, History & Product Lists

**Turn any PriceCharting collection page (a full Pokémon set, a game console, a
comic run, a coin series) into one clean JSON record: the collection's historical
index value and median-price time series, plus every product in the set with its
name, ID, image and current prices.**

Paste a collection URL (or bare slug) and get back one tidy record per
collection — ready for a spreadsheet, database, dashboard, or app. No browser
automation, and **you are never billed for failed lookups**.

> Companion to the **PriceCharting Product Scraper**, which scrapes individual
> product pages (full grade ladder, per-condition price history, sold listings,
> POP report, gallery images). Use *this* actor when you want the **whole set**
> at once; use that one when you want **deep detail on specific products**.

---

### What it does

Given `https://www.pricecharting.com/console/pokemon-1999-topps-movie`, it:

1. Reads the collection header — name, category, the **PriceCharting Index value**
   and **median card price**, and the full **historical time-series** behind the
   page's chart (both the index-value and median series).
2. Pages through the **entire product table** (the site loads 150 at a time; this
   actor follows the "more results" pagination to the end automatically) and
   captures every product: name, numeric ID, canonical URL, full-resolution
   image, and the three listed prices.
3. Emits **one dataset record per collection**, with all products nested inside.

Non-collection pages (typos, removed sets) are reported in the run `SUMMARY` and
are **never written to the dataset or billed**.

---

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| **Collections** *(required)* | list | – | One per line: a `/console/<slug>` URL or a bare slug (e.g. `pokemon-1999-topps-movie`). |
| **Include the product list** | boolean | `true` | Scrape every product in the set into the `products` array. Turn off for collection stats + history only (one page, much faster on huge consoles). |
| **Include the collection price history** | boolean | `true` | Include the full value/median history series. The current value & median are always included. |
| **Max products per collection** | integer | `0` | Cap products scraped per collection (`0` = whole set). |
| **Proxy configuration** | object | Automatic | Datacenter is reliable and cheapest; switch to residential only on failures. |
| **Max concurrency** | integer | `3` | Collections fetched in parallel (pagination within a collection is always sequential). |
| **Delay between requests** | integer | `1` | Politeness delay (seconds) before each request, pagination included. |
| **Max collections** | integer | `0` | Stop after N collection records (`0` = unlimited). |

---

### Output

Each collection becomes one dataset record:

| Field | Description |
|---|---|
| `collectionUrl`, `collectionName` | The page URL and clean set/console name |
| `category`, `consoleUid`, `breadcrumb` | PriceCharting category, internal UID, and the breadcrumb trail |
| `currency` | Always `USD` |
| `priceColumns` | Maps the stable price keys to this category's on-site labels (cards: `used`=Ungraded, `cib`=Grade 9, `new`=PSA 10; games: Loose / CIB / New) |
| `productCount` | Number of products scraped (`null` if the product list was disabled) |
| `currentValue`, `currentMedian` | Latest index value and median card price (USD) |
| `valueHistory`, `medianHistory` | Per-series arrays of `{ "date": "YYYY-MM-DD", "price": 12.34 }` points |
| `products` | One entry per product: `{ productId, productName, url, imageUrl, prices: { used, cib, new } }` |
| `source`, `scrapedAt` | `scrape`; ISO timestamp |

#### Example (products & history truncated)

```jsonc
{
  "collectionUrl": "https://www.pricecharting.com/console/pokemon-1999-topps-movie",
  "collectionName": "Pokemon 1999 Topps Movie",
  "category": "pokemon-cards",
  "consoleUid": "G52737",
  "breadcrumb": ["Trading Cards", "Pokemon Card", "Pokemon 1999 Topps Movie"],
  "currency": "USD",
  "priceColumns": { "used": "Ungraded", "cib": "Grade 9", "new": "PSA 10" },
  "productCount": 201,
  "currentValue": 24.70,
  "currentMedian": 2.23,
  "valueHistory":  [ { "date": "2022-07-02", "price": 4.62 }, "…", { "date": "2026-06-02", "price": 24.70 } ],
  "medianHistory": [ { "date": "2022-07-02", "price": 2.44 }, "…", { "date": "2026-06-02", "price": 2.23 } ],
  "products": [
    {
      "productId": 3560849,
      "productName": "Pikachu's Vacation #42",
      "url": "https://www.pricecharting.com/game/pokemon-1999-topps-movie/pikachu%27s-vacation-42",
      "imageUrl": "https://storage.googleapis.com/images.pricecharting.com/…/1600.jpg",
      "prices": { "used": 3.64, "cib": 33.73, "new": 154.81 }
    }
  ],
  "source": "scrape",
  "scrapedAt": "2026-06-17T06:27:41+00:00"
}
````

For the **per-condition price history, full grade ladder (PSA/BGS/CGC/…), sold
listings and gallery images** of an individual product, feed its `url` or
`productId` into the **PriceCharting Product Scraper**.

***

### Notes

- Prices are normalized to **USD** (the `currency=usd` cookie pins it regardless
  of run geo).
- The three per-product price columns are whatever PriceCharting shows for that
  category — read `priceColumns` to know what `used`/`cib`/`new` mean for your set.
- This project is not affiliated with, endorsed by, or sponsored by
  PriceCharting. Please scrape responsibly — keep concurrency low and delays
  reasonable.

# Actor input Schema

## `collections` (type: `array`):

One entry per line. Each entry is either a full PriceCharting collection page URL (e.g. https://www.pricecharting.com/console/pokemon-1999-topps-movie) or a bare collection slug (e.g. pokemon-1999-topps-movie).

## `includeProducts` (type: `boolean`):

When enabled (default), every product in the collection is scraped (paging through all results) and returned in the 'products' array with name, ID, image and listed prices. Disable to fetch only the collection-level stats and history (a single page, much faster/cheaper for large consoles).

## `includePriceHistory` (type: `boolean`):

When enabled (default), the full historical time-series for the collection's index value and median card price are included. The current value and median are always included regardless.

## `maxProductsPerCollection` (type: `integer`):

Stop paging through a collection after this many products. 0 = no limit (scrape the whole set). Use this to cap very large consoles.

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

Proxies used for scraping. Automatic (datacenter) proxies work reliably against PriceCharting and keep your platform costs near zero. Switch to residential groups only if you see failed requests.

## `maxConcurrency` (type: `integer`):

Maximum number of collection pages fetched in parallel. Pagination within a single collection is always sequential. Keep this low to stay respectful of the target site.

## `requestDelaySecs` (type: `integer`):

Politeness delay applied before each page request, including each pagination request within a collection.

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

Stop after producing this many collection records. Set to 0 for no limit.

## Actor input object example

```json
{
  "collections": [
    "https://www.pricecharting.com/console/super-nintendo",
    "pokemon-1999-topps-movie"
  ],
  "includeProducts": true,
  "includePriceHistory": true,
  "maxProductsPerCollection": 0,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "maxConcurrency": 3,
  "requestDelaySecs": 1,
  "maxItems": 0
}
```

# Actor output Schema

## `collections` (type: `string`):

All scraped collection records (one item per collection page).

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

JSON summary of the run: totals, successes, failures, and product counts.

# 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 = {
    "collections": [
        "https://www.pricecharting.com/console/pokemon-1999-topps-movie"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("incognito_mode/pricecharting-collection-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 = {
    "collections": ["https://www.pricecharting.com/console/pokemon-1999-topps-movie"],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("incognito_mode/pricecharting-collection-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 '{
  "collections": [
    "https://www.pricecharting.com/console/pokemon-1999-topps-movie"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call incognito_mode/pricecharting-collection-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "PriceCharting Collection Scraper",
        "description": "Scrape an entire PriceCharting collection/console page (e.g. a full Pokemon set or game console) in one record: the collection's historical value and median-price time series, plus every product in the set with its name, ID, image and listed prices. Failed lookups are never billed.",
        "version": "0.1",
        "x-build-id": "FD7UeHKxZ6qgajuoh"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/incognito_mode~pricecharting-collection-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-incognito_mode-pricecharting-collection-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/incognito_mode~pricecharting-collection-scraper/runs": {
            "post": {
                "operationId": "runs-sync-incognito_mode-pricecharting-collection-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/incognito_mode~pricecharting-collection-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-incognito_mode-pricecharting-collection-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",
                "required": [
                    "collections"
                ],
                "properties": {
                    "collections": {
                        "title": "Collections (console/collection URLs or slugs)",
                        "type": "array",
                        "description": "One entry per line. Each entry is either a full PriceCharting collection page URL (e.g. https://www.pricecharting.com/console/pokemon-1999-topps-movie) or a bare collection slug (e.g. pokemon-1999-topps-movie).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeProducts": {
                        "title": "Include the product list",
                        "type": "boolean",
                        "description": "When enabled (default), every product in the collection is scraped (paging through all results) and returned in the 'products' array with name, ID, image and listed prices. Disable to fetch only the collection-level stats and history (a single page, much faster/cheaper for large consoles).",
                        "default": true
                    },
                    "includePriceHistory": {
                        "title": "Include the collection price history",
                        "type": "boolean",
                        "description": "When enabled (default), the full historical time-series for the collection's index value and median card price are included. The current value and median are always included regardless.",
                        "default": true
                    },
                    "maxProductsPerCollection": {
                        "title": "Max products per collection",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Stop paging through a collection after this many products. 0 = no limit (scrape the whole set). Use this to cap very large consoles.",
                        "default": 0
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxies used for scraping. Automatic (datacenter) proxies work reliably against PriceCharting and keep your platform costs near zero. Switch to residential groups only if you see failed requests.",
                        "default": {
                            "useApifyProxy": true
                        }
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency (collections in parallel)",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Maximum number of collection pages fetched in parallel. Pagination within a single collection is always sequential. Keep this low to stay respectful of the target site.",
                        "default": 3
                    },
                    "requestDelaySecs": {
                        "title": "Delay between requests (seconds)",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Politeness delay applied before each page request, including each pagination request within a collection.",
                        "default": 1
                    },
                    "maxItems": {
                        "title": "Max collections",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Stop after producing this many collection records. Set to 0 for no limit.",
                        "default": 0
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
