PriceCharting Video Game Prices Scraper

Turn public PriceCharting pages into structured video game valuation data.

Search by game title, paste a PriceCharting search URL, or target an exact product page.

Get loose, complete-in-box, new, graded, box-only, and manual-only values in one record.

Add recent visible sold comps when you need evidence behind the guide price.

Use the output for inventory repricing, collection valuation, purchasing, insurance, and market monitoring.

No PriceCharting login or paid API key is required for the public data extracted by this Actor.

What does PriceCharting Video Game Prices Scraper do?

The Actor reads public PriceCharting search and video game product pages over HTTP.

For every matched video game it extracts:

• 🎮 game title and console
• 🔗 canonical PriceCharting URL and PriceCharting ID
• 🏷️ UPC/EAN, ASIN, and eBay ePID when shown
• 🧑‍💻 publisher, developer, release date, genre, and ESRB rating
• 💵 loose, CIB, new, graded, box-only, and manual-only prices
• 📈 current price deltas and displayed sales velocity
• 🖼️ public product image URLs
• 🧾 bounded visible sold listings with date, condition, price, and source URL

Search pages can mix games with cards or other collectibles.

This Actor verifies product metadata and rejects non-video-game templates rather than returning misleading records.

Who is this video game price scraper for?

Retro game stores can refresh condition-level values before repricing shelves or online inventory.

Resellers can compare acquisition cost with loose, CIB, and recent sold values.

Collectors can build repeatable snapshots for a personal collection without manual copy and paste.

Insurance and estate teams can attach source identifiers and timestamps to valuation records.

Developers can feed normalized PriceCharting data into dashboards, alerts, and internal tools.

Market researchers can compare value changes and sales velocity across consoles.

Why use this Actor?

PriceCharting pages are useful to people but awkward for automated workflows.

The Actor turns each game into a stable JSON row with numeric prices.

You do not need to maintain selectors, retry logic, URL validation, exports, or Apify integrations.

It uses lightweight HTTP extraction instead of a browser, keeping normal runs fast and inexpensive.

Inputs from multiple searches and product URLs are deduplicated by PriceCharting ID.

A complete extraction failure exits with an error instead of silently succeeding with an empty dataset.

What data can I extract?

Field	Description
title	Video game title
console	PriceCharting console or platform
canonicalUrl	Canonical product URL
priceChartingId	PriceCharting product identifier
upc	One or more displayed UPC/EAN codes
asin / epid	Amazon ASIN and eBay ePID when available
genre / esrbRating	Game classification metadata
publisher / developer	Displayed company metadata
releaseDate	Displayed release date
loosePrice	Current loose value in USD
cibPrice	Current complete-in-box value in USD
newPrice	Current new value in USD
gradedPrice	Current graded value in USD
boxOnlyPrice	Current box-only value in USD
manualOnlyPrice	Current manual-only value in USD
*PriceChange	Displayed dollar change for each condition
*SalesVelocity	Displayed sale frequency for each condition
soldCompCount	Visible sold records saved for the game
scrapedAt	UTC extraction timestamp

Separate Sold Comps dataset

Sold listings are a different entity from game valuations.

They are saved to the named Visible Sold Comps dataset instead of being mixed into the default table.

Each comp includes:

• related game title, URL, and PriceCharting ID
• PriceCharting condition such as Loose or Complete
• sale title and sale date
• normalized numeric sale price
• marketplace label when visible
• source listing URL when visible
• scrape timestamp

Set includeSoldComps to false if you only need current guide values.

Use maxSoldCompsPerProduct to bound history volume.

How much does it cost to scrape PriceCharting game prices?

The Actor uses pay-per-event pricing.

A small start event covers fixed run setup, and each successfully saved dataset record is one item event.

That means one event for a game valuation and one event for each requested visible sold-comp row. Failed lookups and skipped non-game product templates are not item events.

Pricing uses a $0.005 start and tiered item rates; the BRONZE rate is $0.0004136 per successfully extracted dataset record.

Apify plan tiers receive decreasing item rates at higher plan levels.

Your exact run total appears in Apify Console before and after execution.

Keep maxItems small for your first run, review the matches, and then scale.

How to scrape PriceCharting in 5 steps

1. Open the Actor input page.
2. Enter one or more specific game searches, such as Super Mario Bros NES.
3. Optionally add exact PriceCharting search or game product URLs.
4. Choose the game limit and sold-comp limit.
5. Start the Actor and export the Video Game Values and Visible Sold Comps datasets.

Specific search terms that include the console usually produce the best matches.

Input parameters

Game searches

searchTerms accepts an array of text searches.

Examples include Pokemon Red GameBoy, Sonic the Hedgehog Genesis, and Zelda NES.

PriceCharting URLs

startUrls accepts public PriceCharting /search-products and /game/... URLs.

Other domains and unsupported PriceCharting routes fail validation.

Limits

maxItems controls unique game rows and supports 1 to 1,000.

maxSoldCompsPerProduct supports 0 to 100 visible sales per game.

Connection

proxyConfiguration is optional.

Direct requests normally work; a proxy can help larger repeated jobs if the source rate-limits traffic.

Example input

{
  "searchTerms": ["Super Mario Bros NES"],
  "startUrls": [
    { "url": "https://www.pricecharting.com/game/gameboy/pokemon-red" }
  ],
  "maxItems": 5,
  "includeSoldComps": true,
  "maxSoldCompsPerProduct": 5
}

You can use only searches, only URLs, or combine them.

Duplicate product URLs are removed automatically.

Example game output

{
  "title": "Pokemon Red",
  "console": "GameBoy",
  "canonicalUrl": "https://www.pricecharting.com/game/gameboy/pokemon-red",
  "priceChartingId": "2985",
  "upc": ["045496730734", "045496460716"],
  "publisher": "Nintendo",
  "developer": "Game Freak",
  "genre": "RPG",
  "loosePrice": 60.03,
  "cibPrice": 329.95,
  "newPrice": 3400,
  "looseSalesVelocity": "3 sales per day",
  "soldCompCount": 5,
  "scrapedAt": "2026-07-20T06:01:52.635Z"
}

Prices are numbers in USD, not formatted strings.

Unavailable optional metadata is returned as null.

Tips for accurate valuation workflows

• 🔎 Include the console in search terms to reduce ambiguous matches.
• 🔗 Use a direct product URL when valuing a known catalog item.
• 📦 Compare the condition that matches your actual inventory.
• 🧾 Use sold comps as supporting evidence, not as guaranteed complete market history.
• 🕐 Save scrapedAt when building historical snapshots.
• 🧪 Start with two to five games before running a large inventory batch.
• 🔁 Schedule repeated runs at a cadence appropriate for your catalog.

PriceCharting values can change between runs as source data updates.

Integrations and automation patterns

Export both datasets as JSON, CSV, Excel, XML, or RSS through Apify.

Send the default dataset to Google Sheets for a buyer or store pricing review.

Use Make or Zapier to notify a purchasing channel when a value crosses a threshold.

Load snapshots into BigQuery, Snowflake, or PostgreSQL for price-trend analysis.

Join priceChartingId with your inventory SKU table for repeatable repricing.

Use webhooks to trigger a downstream insurance report after a scheduled collection refresh.

JavaScript API usage

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/pricecharting-video-game-prices-scraper').call({
  searchTerms: ['Super Mario Bros NES'],
  maxItems: 5,
  includeSoldComps: true,
  maxSoldCompsPerProduct: 5,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);

The default dataset contains game valuation rows.

Named sold-comp dataset access is available from the run storage view in Apify Console.

Python API usage

import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/pricecharting-video-game-prices-scraper').call(run_input={
    'startUrls': [{'url': 'https://www.pricecharting.com/game/gameboy/pokemon-red'}],
    'maxItems': 1,
    'includeSoldComps': True,
    'maxSoldCompsPerProduct': 10,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)

Store the token in an environment variable rather than source code.

cURL API usage

curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~pricecharting-video-game-prices-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"searchTerms":["Zelda NES"],"maxItems":3,"includeSoldComps":true,"maxSoldCompsPerProduct":5}'

Poll the returned run ID or attach a webhook for asynchronous workflows.

Never publish your API token in client-side code.

Use with Apify MCP

Add the Actor to Claude Code:

$claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/pricecharting-video-game-prices-scraper"

For Claude Desktop, Cursor, or VS Code, use this MCP configuration:

{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/pricecharting-video-game-prices-scraper"
    }
  }
}

Example prompts:

• “Extract the current PriceCharting values for Pokemon Red on GameBoy.”
• “Build a five-game NES valuation table with recent visible sold comps.”
• “Compare loose and CIB values for these PriceCharting product URLs.”

MCP lets an assistant start the Actor and reason over structured results.

Scheduling a price monitor

Create an Apify Task with fixed search terms or product URLs.

Run it daily, weekly, or monthly using Apify Schedules.

Send the dataset to your database or compare it with the prior snapshot.

Use canonicalUrl or priceChartingId as the stable join key.

Alert only on changes large enough to matter for your workflow.

Remember that the Actor extracts current public source data; it does not retain your prior runs automatically.

Reliability and limits

The Actor uses bounded retries for rate limits and temporary server errors.

Requests are deliberately sequential to reduce pressure on PriceCharting.

Large search pages can include many collectible matches before game results.

The Actor scans more candidates than it saves, then stops at maxItems video games.

Markup or source access can change without notice.

The visible sold rows are bounded and may not represent every historical transaction.

Paid PriceCharting API data and paid Time Warp photos are outside this product.

Troubleshooting

Why did my search return unexpected editions?

Add the console, region, or edition to the search text, or use exact product URLs.

Why did the run say no video-game records were extracted?

The input may target cards, comics, coins, an unsupported route, or a search with no matching games. Check the URL and use a game-specific query.

Why was the run rate-limited?

Reduce batch size, retry later, or configure an Apify Proxy session.

Why are some identifiers null?

PriceCharting does not show every catalog identifier on every product page.

Is scraping PriceCharting legal?

This Actor accesses public pages without login and does not bypass paid API access.

You are responsible for your use of the data and for following applicable laws and terms.

Avoid excessive request volume and do not use the output to infringe copyrights or trademarks.

PriceCharting, game titles, console names, and marketplace names belong to their respective owners.

This Actor is an independent extraction tool and is not affiliated with PriceCharting.

For regulated insurance or financial decisions, apply your own review and valuation methodology.

FAQ

Does it support trading cards or comics?

No. v1 intentionally fails closed to video games; collectible templates are skipped.

Can I scrape one exact game?

Yes. Pass its public PriceCharting /game/... URL with maxItems: 1.

Are sold comps included?

Yes, when includeSoldComps is true. They appear in a separate named dataset.

Can I export to CSV or Excel?

Yes. Use Apify dataset export controls or API endpoints.

Does it need residential proxy traffic?

Not normally. Direct HTTP is the default; proxy configuration is optional.

Does it return complete price history?

It returns current displayed values, deltas, velocity, and a bounded set of visible sold listings—not paid or complete history.

Related scrapers

Combine this Actor with eBay Sold Listings Scraper for a broader resale-comps workflow.

Use eBay Scraper to inspect active marketplace listings alongside guide values.

Explore other public data tools from Automation Lab.

Choose related tools only when their source and workflow match your valuation task.

Data freshness and responsible use

Every output row includes an extraction timestamp.

Store snapshots if you need trend history because current pages change over time.

Use modest schedules and limits to avoid unnecessary load and cost.

Review outliers manually before changing high-value inventory prices.

Treat guide values and marketplace transactions as evidence, not guarantees of a future sale.

Start with a narrow sample, validate the results against the source, and then automate confidently.