# PriceCharting Scraper - Game & Card Prices, No Start Fee (`gio21/pricecharting-scraper`) Actor

Scrape PriceCharting prices for video games, Pokemon and sports cards, comics and sealed products. Correct price label per category (Loose, CIB, New or Ungraded, Grade 9, PSA 10). $0.005 per product, no actor-start fee, no browser needed.

- **URL**: https://apify.com/gio21/pricecharting-scraper.md
- **Developed by:** [Gio](https://apify.com/gio21) (community)
- **Categories:** E-commerce
- **Features:** Limited permissions
- **Stats:** 12 total users, 8 monthly users, 99.2% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$5.00 / 1,000 product scrapeds

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

## PriceCharting Scraper - Game & Card Prices, No Start Fee

Scrape current market prices from [PriceCharting](https://www.pricecharting.com) for video games, Pokemon and sports cards, comics, LEGO sets and sealed collectibles. Search by keyword, point at a product URL, or pull an entire console/set listing in one run. No browser, no proxy tier to pick, no per-run start fee: you pay only for products actually returned.

### Why use this scraper

Collectors, resellers and marketplace sellers all need the same thing from PriceCharting: the right number next to the right label. The catch is that PriceCharting reuses the same internal data fields for every product category, which is why a lot of scrapers return a Pokemon card's PSA 10 price mislabeled as "new_price", or a sealed video game's CIB price mixed up with its loose price. If you are pricing a collection, matching an eBay listing to the market, or feeding a dashboard, a mislabeled field is worse than no data at all because it looks correct until someone checks it.

This Actor reads the actual condition labels off the page for each category instead of assuming a fixed schema. A Pokemon card comes back with `ungraded`, `grade_7`, `grade_8`, `grade_9`, `grade_9.5` and `psa_10`. A video game comes back with `loose_price`, `complete_price` (CIB), `new_price`, `graded_price`, `box_only_price` and `manual_only_price`. You get the label PriceCharting itself uses, every time, so downstream code never has to guess which number means what.

### Overview

Input is a list of search terms, direct product URLs, or console/set listing URLs; you can mix all three in one run. Output is one JSON object per product: name, console or set, category, the full price table for that category, currency, and whatever extra attributes the product page publishes (release date, publisher, genre, card number, print run, UPC, eBay and TCGplayer IDs). Runs are plain HTTP, no headless browser, so a batch of a few hundred products typically finishes in under two minutes. Pricing is pay-per-result: $0.005 per product scraped, no actor-start charge and no memory-tier charge, so a failed or empty search never costs you anything beyond the search request itself.

### Supported inputs

- **Search queries** (`searchQueries`) - free text like `"charizard base set"` or `"zelda ocarina n64"`. The Actor runs PriceCharting's own search and scrapes the top matches up to `maxItems`.
- **Product URLs** (`productUrls`) - direct links such as `https://www.pricecharting.com/game/pokemon-base-set/charizard-4`. These are always scraped first and are the fastest, most reliable mode because there is no search step to fail.
- **Console / set URLs** (`listUrls`) - a console or card-set page such as `https://www.pricecharting.com/console/pokemon-base-set`. The Actor paginates through the full listing and scrapes every product in it, up to `maxItems`.
- **Max items** (`maxItems`) - caps total products returned across all input modes combined, so you control spend from the input, not after the fact.
- **Include price history** (`includePriceHistory`) - when true, adds the historical price chart series for each product. Off by default because it roughly doubles payload size.

### Use cases

- **Resellers and flippers** pricing inventory before listing on eBay, TCGplayer or a storefront, so the asking price matches the current market instead of last month's.
- **Collectors** tracking the value of a personal collection over time by re-running the same `productUrls` list monthly and diffing the prices.
- **Marketplace and price-comparison tools** that need a clean, labeled price feed for games and cards instead of scraping PriceCharting pages by hand in the browser.
- **Grading arbitrage traders** who compare the spread between a raw card's ungraded price and its PSA 10 price to decide whether submitting for grading is worth it.
- **Data teams** bulk-pricing an entire console library or trading-card set in one run via `listUrls`, instead of looking up products one at a time.

### How it works

The Actor requests each page over plain HTTP and reads the price table and product attributes straight out of the page's own markup, rather than assuming one fixed set of field names for every category. It detects whether a page is a video game, trading card, comic or sealed product from the page itself, then maps that category's condition columns to the matching output fields. Console and set listing pages are paginated automatically until every product on the list has been visited or `maxItems` is reached. No headless browser is launched, which keeps runs fast and avoids the failure modes that come with rendering a full page.

### Input configuration

Search by keyword:

```json
{
  "searchQueries": ["charizard base set", "zelda ocarina of time n64"],
  "maxItems": 20
}
```

Direct product URLs (fastest, no search step):

```json
{
  "productUrls": [
    "https://www.pricecharting.com/game/pokemon-base-set/charizard-4",
    "https://www.pricecharting.com/game/super-nintendo/chrono-trigger"
  ]
}
```

Full console or set listing, with price history:

```json
{
  "listUrls": ["https://www.pricecharting.com/console/pokemon-base-set"],
  "maxItems": 150,
  "includePriceHistory": true
}
```

### Output sample

Trading card:

```json
{
  "url": "https://www.pricecharting.com/game/pokemon-base-set/charizard-4",
  "name": "Charizard #4",
  "console": "Pokemon Base Set",
  "category": "trading-card",
  "prices": {
    "ungraded": { "label": "Ungraded", "price": 446.29 },
    "grade_9": { "label": "Grade 9", "price": 3309.38 },
    "psa_10": { "label": "PSA 10", "price": 24077.5 }
  },
  "currency": "USD",
  "genre": "Pokemon Card",
  "release_date": "January 9, 1999",
  "publisher": "Wizards of the Coast",
  "card_number": "#4",
  "tcgplayer_id": "42382",
  "pricecharting_id": "630417"
}
```

Video game:

```json
{
  "url": "https://www.pricecharting.com/game/super-nintendo/chrono-trigger",
  "name": "Chrono Trigger",
  "console": "Super Nintendo",
  "category": "video-game",
  "prices": {
    "loose_price": { "label": "Loose Price", "price": 283.5 },
    "complete_price": { "label": "Complete Price", "price": 962.49 },
    "new_price": { "label": "New Price", "price": 1563.74 },
    "graded_price": { "label": "Graded Price", "price": 10587.48 }
  },
  "currency": "USD",
  "genre": "RPG",
  "release_date": "March 11, 1995",
  "publisher": "Squaresoft",
  "upc": "094689151047",
  "pricecharting_id": "6889"
}
```

(Both items above are live output from this Actor's own reference run; prices move with the market and will differ by the time you run it.)

### Key output fields

| Field | Type | Description |
|---|---|---|
| `url` | string | Product page URL that was scraped |
| `name` | string | Product name as listed on PriceCharting |
| `console` | string | Console, set or category grouping |
| `category` | string | `video-game`, `trading-card`, `comic` or `sealed-product` |
| `prices` | object | Condition-labeled price map; keys vary by category |
| `currency` | string | Always `USD` (PriceCharting is a US-dollar market) |
| `release_date` | string | Publication or release date, when published |
| `publisher` | string | Publisher or manufacturer, when published |
| `card_number` | string | Card number within its set (trading cards only) |
| `upc` / `asin_amazon` / `epid_ebay` / `tcgplayer_id` | string | Cross-reference IDs to match this product on other marketplaces |
| `scrapedAt` | string | ISO timestamp of the scrape |

### Pricing

Pay-per-event, current rates on this Actor:

| Event | Price |
|---|---|
| Product scraped | $0.005 per product |

That is $5.00 per 1,000 products, with no charge for starting the run and no memory-tier surcharge. A search that returns zero matches costs nothing beyond the search request itself.

### What makes this richer than the competition

Two other PriceCharting scrapers on the Apify Store cover the same site. `incognito_mode/pricecharting-product-scraper` (12 users in the last 30 days) adds price history and sold-listing data but charges a separate Actor Start event on top of its per-result price, so short runs pay a fixed overhead regardless of how many products come back. `lulzasaur/pricecharting-scraper` (4 users in the last 30 days) also bills an Actor Start event in addition to its per-result charge. This Actor's pricing has exactly one chargeable event, product scraped, so a 3-product test run and a 300-product batch both cost only for the products you actually get back, and the category-aware labeling (grade-by-grade for cards, condition-by-condition for games) means you never have to post-process field names before using the data.

### Notes & limitations

- Prices reflect PriceCharting's own listed market values in USD; they are not a guarantee of sale price on any marketplace.
- Only public, non-checkout pages are requested; this Actor does not log in, does not place bids, and does not access account-specific data.
- Very niche or newly listed products may have incomplete price tables (not every condition is tracked for every item) because PriceCharting itself has not collected enough sales data yet; this shows up as missing keys in `prices`, not as an error.
- Comic and sealed-product pages have less standardized attribute sets than games and cards, so expect fewer extra fields (genre, publisher, etc.) outside of `prices` for those categories.
- This Actor is not affiliated with, endorsed by, or sponsored by PriceCharting.

### FAQ

**Does this work for sports cards, not just Pokemon?** Yes, any PriceCharting category uses the same `productUrls`/`listUrls`/`searchQueries` inputs; sports cards follow the trading-card price schema (ungraded through PSA 10).

**Can I track price history, not just the current price?** Yes, set `includePriceHistory: true` to add the historical chart series to each product.

**What happens if a search term matches nothing?** The run finishes successfully with zero items for that query and you are not charged for it; other queries in the same run are unaffected.

**Can I scrape an entire console's catalog in one run?** Yes, pass the console or set page to `listUrls` and the Actor paginates through the full listing up to `maxItems`.

**Does it need a paid proxy?** No, datacenter proxy (Apify's default) is enough; the site does not require residential IPs for these pages.

**Is pricing in anything other than USD?** No, PriceCharting itself only publishes USD prices, so all output uses `currency: "USD"`.

### For AI Agents & LLM Apps

This Actor is callable directly from an MCP client via `mcp.apify.com`, or from any backend with the Apify API. Example using the synchronous dataset endpoint, which runs the Actor and returns the dataset items in a single call:

```bash
curl "https://api.apify.com/v2/acts/YOUR_USERNAME~pricecharting-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{"productUrls": ["https://www.pricecharting.com/game/pokemon-base-set/charizard-4"]}'
```

The response is a plain JSON array of the price objects shown above, ready to hand to an LLM agent or to insert directly into a pricing pipeline.

### Disclaimer

This Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by PriceCharting. "PriceCharting" is a trademark of its respective owner; it is referenced here only to describe the site this Actor reads public price data from.

### SEO Keywords

PriceCharting scraper, PriceCharting API, video game price scraper, Pokemon card price scraper, trading card price scraper, PSA 10 price scraper, collectible price tracker, PriceCharting dataset

# Actor input Schema

## `searchQueries` (type: `array`):

Product names to search on PriceCharting, e.g. "charizard base set" or "zelda ocarina n64".

## `productUrls` (type: `array`):

Direct PriceCharting product pages, e.g. https://www.pricecharting.com/game/pokemon-base-set/charizard-4

## `listUrls` (type: `array`):

Console or set pages to pull every product from, e.g. https://www.pricecharting.com/console/pokemon-base-set

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

Maximum number of products to scrape.

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

Also return the historical price chart data for each product (bigger output).

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

Apify Proxy settings. Datacenter proxy is enough for this site.

## Actor input object example

```json
{
  "searchQueries": [
    "charizard base set"
  ],
  "maxItems": 100,
  "includePriceHistory": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `results` (type: `string`):

All scraped products - name, console/set, category, prices by condition and extra attributes.

# 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 = {
    "searchQueries": [
        "charizard base set"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("gio21/pricecharting-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 = { "searchQueries": ["charizard base set"] }

# Run the Actor and wait for it to finish
run = client.actor("gio21/pricecharting-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 '{
  "searchQueries": [
    "charizard base set"
  ]
}' |
apify call gio21/pricecharting-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,gio21/pricecharting-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/atUdU0A0Dl3IKZCuC/builds/OJoKfq6xcRAhe0jeT/openapi.json