# PriceCharting Prices Scraper · Price history · $4/1K (`mlg14/pricecharting-scraper`) Actor Get PriceCharting prices for video games, trading cards and collectibles for resale research, collection valuation and market tracking. Input product URLs or IDs; returns current prices, price guide and monthly history. $4/1K products. - **URL**: https://apify.com/mlg14/pricecharting-scraper.md - **Developed by:** [MLG Data](https://apify.com/mlg14) (community) - **Categories:** E-commerce, Automation - **Stats:** 2 total users, 1 monthly users, 50.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing $4.00 / 1,000 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/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 Scrape PriceCharting product pages to collect current market prices, complete price guides, product metadata, images, and monthly price history. Export PriceCharting data to JSON, CSV, or Excel, and use product URLs or numeric IDs as a practical alternative to a subscription API for public catalog pages. ### What data can you extract from PriceCharting? The actor returns one flat dataset item per distinct product page. Product pages cover games, trading cards, collectibles, and other categories listed in the catalog. Some values are category specific, and the source page can leave fields blank when no catalog value exists. | Field | Description | Example | |---|---|---| | `productId` | Numeric identifier used by the catalog. | `7141` | | `productName` | Product title as shown in the page heading. | `Super Mario World` | | `consoleName` | Console, set, or parent collection linked beside the title. | `Super Nintendo` | | `category` | Category slug from the product breadcrumbs. | `video-games` | | `url` | Canonical product page address. | `https://www.pricecharting.com/game/super-nintendo/super-mario-world` | | `releaseDate` | Release date when the product page lists one. | `1991` | | `genre` | Genre when provided by the catalog. | `Platformer` | | `upc`, `epid`, `asin` | Catalog identifiers when they appear on the page. | `045496830014` | | `description` | Product description, when available. | A short product overview. | | `imageUrl` | Main image address at full image size when available. | An image URL ending in `/1600.jpg` | | `images` | Full-size image addresses found in the product gallery. | A list of image URLs. | | `flags` | Category indicators for cards, comics, coins, systems, Funko Pops, and LEGO sets. | `{ "isCard": false, "isComic": false }` | | `currency` | Currency used by the displayed price fields. | `USD` | | `prices` | Six stable price slots for common product conditions. | `{ "loose": 17.43, "cib": 626.61 }` | | `fullPrices` | The complete price guide, retaining the labels printed on the page. | `{ "Loose": 17.43, "Complete": 626.61 }` | | `salesVolume` | Count of completed-sale rows available on the page for each condition. | `{ "Loose": 30, "Complete": 30 }` | | `populationReport` | Card population counts grouped by grading company and grade, when embedded. | `{ "PSA": { "10": 486 } }` | | `recentSales` | Completed sale details grouped by condition when requested. | Date, title, price, source host, item ID, and URL. | | `priceHistory` | Monthly historical prices grouped by the six stable condition keys. | `{ "used": [{ "date": "2021-02-01", "price": 53.91 }] }` | | `source` | Identifies the collection method. | `scrape` | | `scrapedAt` | UTC time when the product record was collected. | `2026-10-25T12:00:00+00:00` | The six price keys stay consistent across product categories. For video games, `prices.loose`, `prices.cib`, `prices.new`, `prices.graded`, `prices.boxOnly`, and `prices.manualOnly` correspond to Loose, Complete, New, Graded, Box Only, and Manual Only. On trading card pages, those same keys map to Ungraded, Grade 7, Grade 8, Grade 9, Grade 9.5, and PSA 10. Other categories can use different visible labels, so consult `fullPrices` when you need the complete condition ladder. `fullPrices` keys retain the exact labels from the product page and use `null` where the page shows no current value. The history arrays use the keys `used`, `cib`, `new`, `graded`, `boxOnly`, and `manualOnly`. The site does not publish a history series for every individual grade or grading label in `fullPrices`; those conditions are present only as current values when listed. History values are converted from the page's embedded chart data into dollar amounts, and empty zero-price periods are omitted. ### How to scrape PriceCharting 1. Add one product page URL or numeric product ID to **Products** for each item you want to collect. A numeric ID is resolved through its product page. 2. Choose whether to include monthly price history and completed sales. History is on by default; recent sale listings are off by default to keep records smaller. 3. Set a maximum item count, request delay, and concurrency appropriate for the size of your collection. 4. Start the run and open the dataset to inspect or export the product records. Download JSON, CSV, or Excel when you need a file, or retrieve dataset items through the API. This actor accepts individual products. It does not take a search phrase and expand it into results automatically; use the product URLs or IDs you want in the dataset. When you have several products, paste one value per line in the product list. Duplicate product IDs in a single run produce only one dataset item. ### Input | Name | Type | Default | Description | |---|---|---|---| | `products` | List of strings | Super Mario World product page | Product page URLs or numeric product IDs. | | `scrapeProductDetails` | Boolean | `true` | Include the monthly historical price series. Current values and page metadata remain available when disabled. | | `includeRecentSales` | Boolean | `false` | Add completed sale records found in the public page HTML. | | `maxConcurrency` | Integer, 1–3 | `1` | Maximum number of pages fetched at once. | | `requestDelaySecs` | Integer, 0–10 | `2` | Delay before each product request. | | `maxItems` | Integer | `0` | Maximum distinct products to write; `0` means no cap. | | `proxyConfiguration` | Object | Automatic proxy configuration | Proxy settings used for product-page requests. | Example input: ```json { "products": [ "https://www.pricecharting.com/game/super-nintendo/super-mario-world", "https://www.pricecharting.com/game/pokemon-base-set/charizard-4", "7141" ], "scrapeProductDetails": true, "includeRecentSales": false, "maxConcurrency": 1, "requestDelaySecs": 2, "maxItems": 0 } ``` The actor also has a useful default product, so an empty input object can produce a sample result. For a repeatable collection, set `products` explicitly. Product URLs must belong to the PriceCharting domain; numeric values are treated as product IDs. For a low-impact run, keep concurrency at 1–3 and retain a delay. The defaults use one concurrent request and a two-second wait; zero removes the extra wait. ### Output example The following shortened example comes from a golden run. Price values and sale counts are snapshots and can change as the source page is updated. It shows two history points and the six common sale counts; the full record contains every returned series and condition. ```json { "productId": 7141, "productName": "Super Mario World", "consoleName": "Super Nintendo", "category": "video-games", "url": "https://www.pricecharting.com/game/super-nintendo/super-mario-world", "releaseDate": "August 23, 1991", "genre": "Platformer", "upc": "045496830014", "epid": "175892071", "asin": "B00002STXQ", "description": "Mario's off on his biggest adventure ever, and this time he's brought along a friend.", "imageUrl": "https://storage.googleapis.com/images.pricecharting.com/w4tqsjcg7clrvypq/1600.jpg", "images": [ "https://storage.googleapis.com/images.pricecharting.com/w4tqsjcg7clrvypq/1600.jpg", "https://storage.googleapis.com/images.pricecharting.com/056a95dd9c1af98259d6788724429d01a0fd42586bb62cdd2b36c1b4a925598b/1600.jpg" ], "flags": { "isCard": false, "isComic": false, "isCoin": false, "isSystem": false, "isFunkoPop": false, "isLegoSet": false }, "currency": "USD", "prices": { "loose": 17.43, "cib": 626.61, "new": 4259.65, "graded": 9361.38, "boxOnly": 236.82, "manualOnly": 7.0 }, "fullPrices": { "Loose": 17.43, "Item & Box": 254.25, "Item & Manual": 24.0, "Complete": 626.61, "New": 4259.65, "Graded CIB": 1299.95, "Graded New": 9361.38, "Box Only": 236.82, "Manual Only": 7.0 }, "salesVolume": { "Loose": 30, "Complete": 30, "New": 30, "Graded": 28, "Box Only": 9, "Manual Only": 30 }, "priceHistory": { "used": [ { "date": "2006-12-01", "price": 5.99 }, { "date": "2007-01-01", "price": 5.99 } ], "cib": [ { "date": "2011-03-01", "price": 12.11 }, { "date": "2011-04-01", "price": 12.11 } ] }, "source": "scrape", "scrapedAt": "2026-10-25T16:45:03+00:00" } ``` Optional fields vary by product. `populationReport` is added when the card page contains population data. `priceHistory` is added when `scrapeProductDetails` is enabled, and `recentSales` is added only when `includeRecentSales` is enabled. The actual values are taken from the fetched page, not inferred from other products. ### Use cases - Collect the current condition prices for a personal game or card collection before making an inventory spreadsheet. - Compare a shop's selected products over time by scheduling repeat runs and joining datasets by `productId`. - Build a product catalog with page names, parent console or set, category, identifiers, and image URLs. - Review current card price ladders alongside PSA or CGC population counts where the page provides them. - Check recent completed-sale examples for selected products when the extra listing detail is needed. - Export stable product records to a research workflow or an internal valuation process. For price comparisons across runs, keep the product ID as the matching key and retain the collection timestamp. Product names and URLs can change as the catalog is reorganized; the numeric identifier is more stable for joining records. ### How much does it cost to scrape PriceCharting? The actor uses pay-per-result pricing. Its configured actor charge is **$4.00 per 1,000 successful product records**. Failed product lookups do not create dataset items and do not incur this result charge. Approximate actor charges are: | Products returned | Approximate actor charge | |---:|---:| | 30 | $0.12 | | 500 | $2.00 | | 1,000 | $4.00 | These examples multiply the successful result count by the configured event rate. Run compute and proxy usage, if any, can depend on elapsed time, memory, concurrency, and the selected proxy configuration. The actor rate is not a subscription and is charged only for records delivered to the dataset. Set `maxItems` to limit the number of output records, and review the run's spending limit before large collections. History and image URLs are included in a product item and do not create separate dataset events. Enabling `includeRecentSales` expands the item contents but still produces one dataset item for that product. If you are testing a large product list, start with a small `maxItems` value and expand once the returned fields suit your workflow. ### Tips for best results - Prefer canonical product URLs when you already have them. Numeric IDs are convenient for lists but are less readable when reviewing an input file. - Use one product per list entry. The actor ignores blank entries and removes duplicate products by numeric ID. - Keep `scrapeProductDetails` enabled when you need historical chart points. Turn it off when current prices and catalog metadata are enough. - Keep `includeRecentSales` disabled for routine price checks. Completed sale rows can add substantial text and listing URLs to each product record. - Use a lower concurrency when collecting many pages or if requests begin to fail. The maximum is five parallel product requests. - Add a delay for repeated runs or larger collections. A value of one second is the default; zero removes the extra wait. - Start with a small product list to confirm that the selected pages resolve to the intended editions, variants, and grading categories. - Use `fullPrices` to compare category-specific labels. The stable keys in `prices` are convenient for common comparisons but do not represent the same physical condition for every category. ### Limits Each result is based on the public product page returned during that run. The source controls which price points, sale rows, identifiers, images, and population data are available. Fields may be `null`, absent, or empty when a product page does not provide that information. A missing value does not mean the product has no market value; it means the fetched page did not supply a usable value for that field. Historical charts are monthly series for the six common price slots. The actor does not create history for every named grade in the full guide. Price history points with a zero amount are omitted because these generally represent periods before the product had a tracked price. Prices are converted from the chart's cents into decimal USD values and dates are represented in UTC. The `salesVolume` field counts the completed-sale rows present in the fetched product page for each condition. It is not a daily or weekly sales-rate estimate, and it is not a count of every historical sale ever recorded. `recentSales` contains the individual sale rows available in the same page response; the actor does not follow separate listing links or claim to return all past sales. Sale sources can differ by product and may be absent from a row. Population data is only included when embedded on a product page. It is primarily relevant to graded cards, and it can change independently from prices. It should be treated as a page snapshot, not as an official grade certification or a prediction of a future price. Category flags are derived from the category breadcrumb and product title, so they are useful filters rather than official category metadata. This actor accepts individual URLs and IDs rather than search keywords, console-wide inventories, or full collection exports. A product ID that no longer resolves, a malformed URL, or an unexpected page layout is logged and skipped. If every requested product fails, the run fails with a clear message instead of reporting a successful empty dataset. When only some products fail, the available records are still returned, and the run logs identify the failed inputs. The input list is the boundary of each run: no automatic pagination or expansion into related variants is performed. If you want alternate prints, card grades, regions, or product variants, include those product pages as separate inputs. The actor deduplicates repeated numeric IDs, so duplicate entries do not produce duplicate charges or records. ### FAQ **Do I need a product page URL?** No. A numeric product ID can be entered by itself. The actor opens its product page and writes the canonical page URL into the result. **Can I scrape a search phrase or an entire console?** Not in this version. Supply individual product URLs or IDs. Search results can be used to find product pages, but the actor does not expand a search query into a product list. **Why is a price or metadata field empty?** The field may not be present for that product, category, or condition on the source page. Check `fullPrices`, `category`, and the canonical `url` before treating an empty field as a zero value. **Do I need to supply proxy settings?** No. Proxy settings have a default. You can adjust the proxy configuration if your account requires a specific setup, and you can lower concurrency if requests begin to fail. **How fast will a run finish?** Elapsed time depends on the number and size of product pages, the chosen delay, concurrency, and any challenge handling. A small input list should finish quickly; for large lists, use a delay and allow enough run time rather than raising concurrency beyond five. **Can I export to a spreadsheet or schedule a refresh?** Yes. Dataset records can be downloaded as JSON, CSV, or Excel, or read through the dataset API. Runs can be scheduled through the platform's scheduling interface and connected to a webhook or automation workflow. **Are recent sales and price history included by default?** Monthly history is enabled by default. Individual recent sale rows are optional and disabled by default to limit the size of each result. Both options read data already rendered on the product page. **Are the six stable price keys identical to every condition label?** No. They provide a consistent shape across products. For example, the six slots on a card page correspond to Ungraded, Grade 7, Grade 8, Grade 9, Grade 9.5, and PSA 10. Use `fullPrices` to see the exact labels for the product category. ### Use with AI agents (MCP) Add this actor to any MCP client (Claude, Cursor, VS Code, n8n and others) with one URL: `https://mcp.apify.com?tools=mlg14/pricecharting-scraper` Each dataset item is one PriceCharting product (name, console or set, current prices by condition, monthly price history, optional recent sales, image, URL). Keep `maxItems` small so the agent gets a bounded result. **Prompt 1:** "What is the current PriceCharting price of Super Mario World on SNES?" ```json { "products": [ "https://www.pricecharting.com/game/super-nintendo/super-mario-world" ], "maxItems": 1 } ``` **Prompt 2:** "Get the PriceCharting price history of the Pokemon Base Set Charizard." ```json { "products": [ "https://www.pricecharting.com/game/pokemon-base-set/charizard-4" ], "scrapeProductDetails": true, "maxItems": 1 } ``` **Prompt 3:** "Show recent sold listings for PriceCharting product 7141." ```json { "products": [ "7141" ], "includeRecentSales": true, "maxItems": 1 } ``` ### Integrations Download results directly from the dataset as JSON, CSV, or Excel, or read the dataset through the platform API. A webhook can notify a downstream service when a run completes. Scheduled runs are useful for creating price snapshots over time; automation services, spreadsheet imports, and internal applications can consume the resulting records. Use `productId` and `scrapedAt` to join and order snapshots in another data store. ### Support Open an issue on the Issues tab; we reply within 24h and add fields on request. # Actor input Schema ## `products` (type: `array`): PriceCharting product page URLs or numeric product IDs, one entry per product. Example: \["https://www.pricecharting.com/game/pokemon-base-set/charizard-4", "7141"]. Use it for known items. ## `scrapeProductDetails` (type: `boolean`): Include the monthly price history from each product page; current prices, images and catalog details are returned either way. Example: true. Set false for a lighter output. ## `includeRecentSales` (type: `boolean`): Include sale date, title, price, marketplace, item ID and listing URL of completed sales on each page. Example: true. Leave false (default) for smaller items. ## `maxConcurrency` (type: `integer`): Maximum product pages fetched in parallel, 1 to 3. Example: 1. Keep low to avoid request bursts; raise to 3 for faster batches. ## `requestDelaySecs` (type: `integer`): Seconds to wait before each product request, 0 to 10. Example: 2. Use 0 for no added delay; keep 2 (default) for polite scraping. ## `maxItems` (type: `integer`): Stop after this many distinct products. Example: 50. Set 0 for no cap; use it to bound cost on long product lists. ## `proxyConfiguration` (type: `object`): Proxy used to fetch product pages. Keep the default Apify Proxy unless you have your own proxies. ## Actor input object example ```json { "products": [ "https://www.pricecharting.com/game/pokemon-base-set/charizard-4", "7141" ], "scrapeProductDetails": true, "includeRecentSales": false, "maxConcurrency": 1, "requestDelaySecs": 2, "maxItems": 0, "proxyConfiguration": { "useApifyProxy": true } } ``` # Actor output Schema ## `results` (type: `string`): Product records with prices, catalog data, and optional historical sales details. # 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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "products": [ "https://www.pricecharting.com/game/super-nintendo/super-mario-world" ], "proxyConfiguration": { "useApifyProxy": true } }; // Run the Actor and wait for it to finish const run = await client.actor("mlg14/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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "products": ["https://www.pricecharting.com/game/super-nintendo/super-mario-world"], "proxyConfiguration": { "useApifyProxy": True }, } # Run the Actor and wait for it to finish run = client.actor("mlg14/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 '{ "products": [ "https://www.pricecharting.com/game/super-nintendo/super-mario-world" ], "proxyConfiguration": { "useApifyProxy": true } }' | apify call mlg14/pricecharting-scraper --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com/?tools=fetch-actor-details,mlg14/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 ` 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/eUSa3dkPb8xSaTx0i/builds/dlNiJCfFrcbh6ipOI/openapi.json