# PriceCharting Product Scraper (`incognito_mode/pricecharting-product-scraper`) Actor Scrape PriceCharting prices for video games, Pokemon and other TCG cards, comics and coins: every grade (PSA, BGS, CGC, SGC, TAG, ACE), full price history, recent sold listings, POP report and 1600px images. Clean JSON/CSV by product URL or ID. Failed lookups are never billed. - **URL**: https://apify.com/incognito\_mode/pricecharting-product-scraper.md - **Developed by:** [Elena Vance](https://apify.com/incognito_mode) (community) - **Categories:** E-commerce, Integrations, Developer tools - **Stats:** 4 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $5.00 / 1,000 product 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 Product Scraper — Prices, Price History, Graded Values & Images **Turn any PriceCharting product page into clean, structured JSON: current prices for every condition and grade — including PSA, BGS, CGC, SGC, TAG and ACE graded card values — the complete price-history time series, recent sold listings, and full-resolution product images — for video games, Pokémon / Magic / Yu-Gi-Oh! and other trading cards, comics, coins, Funko Pops, and LEGO sets.** Paste a list of product URLs or numeric product IDs and get back one tidy record per item, ready to drop into a spreadsheet, database, dashboard, or app. No browser automation, no HTML wrangling, no $49/month subscription — and **you are never billed for failed lookups**. --- ### Why this Actor - **Full price history — not just today's price.** The entire time series behind PriceCharting's charts (often hundreds of data points per product), per condition. PriceCharting's own official API does **not** return history; this Actor does. - **Full-resolution product images.** The cover photo plus every gallery image (card backs, box / cartridge / manual shots) as direct **1600 px** URLs — ready for your storefront, app, or catalog. - **Every price point, one record.** Loose / CIB / new / graded / box-only / manual-only for games; Ungraded → PSA 10 grade tiers for cards (see the mapping table below). Missing conditions come back as `null`, never a crash. - **The complete grading ladder (`fullPrices`).** Every row of PriceCharting's Full Price Guide with the site's own labels: for cards that means Grade 1-9.5 plus **TAG 10, ACE 10, SGC 10, CGC 10, CGC 10 Pristine, PSA 10, BGS 10 and BGS 10 Black Label**; for games, hybrid conditions like *Item & Box* and *Graded CIB*. Neither the official API nor other scrapers return these. - **Sales volume, POP report, and optional sold listings.** Per-grade counts of recent sales, the PSA/CGC population chart for cards, and (opt-in) the actual recent sold listings — date, title, sale price, and link per eBay / TCGPlayer / Goldin / PWCC / Heritage sale — the raw comps behind every price. - **You never pay for failures.** A dead link, typo, or removed product is reported in the run summary — it is **not** written to your dataset and **not billed**. You pay only for product records you actually receive. - **Fast and cheap by design.** Lightweight HTTP scraping — no headless browser — so runs are quick and compute stays minimal. - **Flexible input.** Full product URLs, bare numeric IDs, or `category/slug` paths — mix them freely in one run. - **Optional official-API mode.** Bring your own PriceCharting API token and numeric IDs are resolved through the sanctioned `/api/product` endpoint. - **Clean, consistent USD output.** Prices normalized to USD floats (2 decimals) regardless of where you run from. --- ### Problems this Actor solves | If you are… | Your problem | How this Actor solves it | |---|---|---| | **A reseller / game or card shop** | Pricing inventory by hand from the website takes hours and goes stale immediately | Re-price your whole inventory in one scheduled run; per-condition prices map directly to what you stock | | **A collector** | You want your collection's value *and its trend*, not a single snapshot | Full price history per condition lets you chart gains/losses over any period | | **A developer building an app or store** | The official API needs a **$49/month** subscription and still returns **no history and no images** | Pay cents per product on demand, get history **and** 1600 px images in one call | | **A market researcher / data analyst** | Chart data is locked inside the site's JavaScript | The exact chart series arrives as dated JSON points you can load into pandas, Sheets, or BI tools | | **An eBay / marketplace seller** | Guessing listing prices leaves money on the table | Pull current prices for every grade **plus the actual recent sold comps** (date, final price, link) for every item before you list | | **A card grader / submitter** | Is grading this card worth the fee? | The full grade ladder in one record — e.g. raw vs Grade 9 vs PSA 10 vs BGS 10 — plus the PSA/CGC POP report and per-grade sales volume to judge the value jump and liquidity | **Efficiency, concretely:** valuing a 1,000-item collection by hand at ~30 seconds per lookup is ~8 hours of clicking. This Actor does it in one run of about 15 minutes, for a few dollars, and gives you the history and images the website lookup never would. --- ### What data you get Each product becomes one dataset record: | Field | Description | |---|---| | `productId` | PriceCharting's numeric product ID | | `productName`, `consoleName` | Product and console / set name (e.g. *Charizard #4*, *Pokemon Base Set*) | | `category` | PriceCharting category (e.g. `video-games`, `pokemon-cards`) | | `url` | Canonical product page URL | | `releaseDate`, `genre`, `upc`, `epid`, `asin` | Catalog metadata where available | | `imageUrl` | Cover photo, full-resolution (1600 px) | | `images` | **All** product photos (cover + gallery: card backs, box/cart/manual shots), 1600 px | | `flags` | Product-type booleans: `isCard`, `isComic`, `isCoin`, `isSystem`, `isFunkoPop`, `isLegoSet`, … | | `currency` | Always `USD` | | `prices` | Current price per condition slot (see mapping below) | | `fullPrices` | **Every** row of the on-page Full Price Guide, labels verbatim — cards: `Ungraded`, `Grade 1`…`Grade 9.5`, `TAG 10`, `ACE 10`, `SGC 10`, `CGC 10`, `PSA 10`, `BGS 10`, `BGS 10 Black`, `CGC 10 Pristine`; games: `Loose`, `Item & Box`, `Graded CIB`, … (`null` = grade tracked, no sales yet) | | `salesVolume` | Number of recent sold listings per grade/condition, same labels as the site | | `populationReport` | Cards only: PSA and CGC population counts per grade 1–10 (the site's POP Report chart) | | `recentSales` | Opt-in (see input): recent sold listings per grade — `{ date, title, price, source, itemId, url }` per sale, from eBay, TCGPlayer, Goldin, PWCC, Heritage | | `priceHistory` | Per-condition arrays of `{ "date": "YYYY-MM-DD", "price": 12.34 }` points | | `source` | `scrape` or `api` | | `scrapedAt` | ISO timestamp | #### What the six price slots mean PriceCharting reuses the same six columns with different labels per category — this Actor keeps stable keys and you read them per category: | Key | Video games | Trading cards | |---|---|---| | `prices.loose` | Loose (cart / disc only) | **Ungraded** | | `prices.cib` | Complete in box | Grade 7 | | `prices.new` | New / sealed | Grade 8 | | `prices.graded` | Graded | Grade 9 | | `prices.boxOnly` | Box only | Grade 9.5 | | `prices.manualOnly` | Manual only | **PSA 10** | (Comics, coins, and other categories follow the same pattern with their own on-site labels.) `priceHistory` uses the same keys, so for a card, `priceHistory.manualOnly` is the **PSA 10 price over time**. If the six slots are not enough, read `fullPrices` instead: it carries the site's complete price guide with the labels exactly as shown on the page — no mapping table needed, and for cards it includes every grading company (TAG / ACE / SGC / CGC / PSA / BGS, plus Black Label and Pristine variants). History exists only for the six slots above — PriceCharting publishes no time series for the company-specific grades, so `fullPrices` is their current market value. #### Example output ```jsonc { "productId": 630417, "productName": "Charizard #4", "consoleName": "Pokemon Base Set", "category": "pokemon-cards", "url": "https://www.pricecharting.com/game/pokemon-base-set/charizard-4", "releaseDate": "January 9, 1999", "imageUrl": "https://storage.googleapis.com/images.pricecharting.com/hpgpcpsd42huitud/1600.jpg", "images": [ "https://storage.googleapis.com/images.pricecharting.com/hpgpcpsd42huitud/1600.jpg", "https://storage.googleapis.com/images.pricecharting.com/kmwn5qjyipwzbuwm/1600.jpg" ], "flags": { "isCard": true, "isComic": false, "isCoin": false }, "currency": "USD", "prices": { "loose": 338.42, // Ungraded "cib": 749.50, // Grade 7 "new": 1199.03, // Grade 8 "graded": 3175.04, // Grade 9 "boxOnly": 3403.50, // Grade 9.5 "manualOnly": 30085.73 // PSA 10 }, "fullPrices": { // the complete on-page price guide, labels verbatim "Ungraded": 338.42, "Grade 1": 354.00, "Grade 2": 277.50, "Grade 3": 325.00, "Grade 4": 330.60, "Grade 5": 450.00, "Grade 6": 504.81, "Grade 7": 749.50, "Grade 8": 1199.03, "Grade 9": 3175.04, "Grade 9.5": 3403.50, "TAG 10": null, // tracked, no sales yet "ACE 10": null, "SGC 10": 18051.00, "CGC 10": 7605.63, "PSA 10": 30085.73, "BGS 10": 39111.00, "BGS 10 Black": 195555.00, "CGC 10 Pristine": 27475.00 }, "salesVolume": { "Ungraded": 48, "PSA 10": 30, "CGC 10": 30, "Grade 9": 30, "…": 0 }, "populationReport": { "PSA": { "1": 20, "2": 19, "…": 0, "9": 9, "10": 0 }, "CGC": { "…": 0, "9": 2, "10": 4 } }, "recentSales": { // only with "Include recent sold listings" enabled "PSA 10": [ { "date": "2026-05-04", "title": "1999 Pokemon Base Set Charizard #4 Holo PSA 10", "price": 30100.00, "source": "ebay", "itemId": "157…", "url": "https://www.ebay.com/itm/157…" } ], "…": [] }, "priceHistory": { "used": [ { "date": "2020-09-01", "price": 180.00 }, { "date": "2020-10-01", "price": 210.50 }, "…" ], "graded": [ "…" ] }, "source": "scrape", "scrapedAt": "2026-06-11T04:24:21+00:00" } ```` Inputs that could not be fetched are **not** written to the dataset (and are never billed). They are listed in the run's `SUMMARY` record in the key-value store — `{ "failures": [ { "input": "…", "source": "scrape", "error": "…" } ] }` — so you can inspect and retry them, and the run's status message tells you at a glance how many succeeded. *** ### How to use it (60 seconds) 1. Click **Try for free / Start**. 2. In **Products**, add one entry per line — a product page URL or a numeric ID: ``` https://www.pricecharting.com/game/super-nintendo/super-mario-world https://www.pricecharting.com/game/pokemon-base-set/charizard-4 7141 ``` 3. (Optional) Toggle **Scrape full product details** off if you only need current prices without the history series. 4. Click **Save & Start**. Download results as **JSON, CSV, Excel, or via API** from the **Dataset** tab; check the **Key-value store → SUMMARY** for run totals and any failed inputs. > **Tip — finding a product ID:** open any product on PriceCharting and hover over > its title — the numeric ID appears. Or just paste the page URL. *** ### Input reference | Field | Type | Default | Description | |---|---|---|---| | **Products** *(required)* | list | – | One per line: product page URL **or** numeric product ID. | | **Scrape full product details** | boolean | `true` | Include the full price-history series. Images are always included for scraped products. | | **Include recent sold listings** | boolean | `false` | Adds `recentSales` (up to ~30 sold listings per grade with date, title, price, link). Increases item size ~5x; leave off if you only need prices. | | **PriceCharting API token** | secret | – | Optional. Resolves numeric IDs through the official API when full details are off (see below). | | **Proxy configuration** | object | Automatic | Proxy used for scraping. Automatic (datacenter) is reliable and the cheapest; switch to residential only if you ever see failed requests. | | **Max concurrency** | integer | `3` | Parallel requests (kept low to be respectful). | | **Delay between requests** | integer | `1` | Politeness delay in seconds (max 10). | | **Max items** | integer | `0` | Stop after N results (`0` = unlimited). | *** ### Pricing — what a run actually costs This Actor uses transparent **pay-per-event** pricing with a built-in **volume discount**: a small Actor-start fee, a fixed price per successful product record for the first 10,000 results of a run, and a ~70% cheaper rate for every result beyond that. No subscription, no minimums, no charges for failures. | Per run | Rate | |---|---| | Results 1 – 10,000 | **$5.00 / 1,000** | | Results 10,001 and up | **$1.50 / 1,000** (automatic volume discount) | | Example job | Approximate cost | |---|---| | Value 50 cards | **≈ $0.27** (start fee + 50 results) | | Re-price a 500-item store inventory | **≈ $2.52** | | 1,000 products with full history + images | **≈ $5.02** | | 100,000 products (bulk tier kicks in) | **≈ $185** | - **Failed lookups are free.** Dead links and removed products are reported in the summary, not billed. - **Bigger runs cost less.** The discount tier resets per run, so one large run is much cheaper than the same job split into many small runs — batch large jobs accordingly. - **Try it free:** an Apify free account includes $5 of monthly platform credit — enough to scrape roughly **1,000 products** with this Actor before paying anything. - **Compare:** PriceCharting's own API requires the **$49/month Legendary subscription** and still returns **no price history, no images, no graded values beyond the basic slots, and no sold listings**. Here you pay per result, get all of it, and there is no commitment. - **Stay in control:** set a **maximum charge per run** (Apify's built-in spending limit) and the Actor stops gracefully at your cap, keeping everything already scraped. #### Bulk runs (10,000+ products) — best practices - Input **bare numeric IDs** instead of full URLs — hundreds of thousands of IDs fit in a single run's input. - Set the run **timeout to unlimited**, keep memory at 1 GB, raise **Max concurrency** to 10–15 and set the delay to 0 — roughly 7–12 products/sec. The request queue survives restarts and migrations. - Set `maxItems` and a maximum charge as guardrails; datasets reach several GB at this scale with history included (export promptly or read via the API). *** ### Compared to the alternatives | | **This Actor** | Official API ($49/mo) | Build your own scraper | Manual lookups | |---|---|---|---|---| | Current prices, all conditions | Yes | Yes | You maintain it | Slow | | **Price history series**| Yes | No | You reverse-engineer the charts | No | | **Graded values: PSA / BGS / CGC / SGC / TAG / ACE** (incl. Black Label, Pristine) | Yes — `fullPrices` | No | You maintain it | One grade at a time | | **Recent sold listings** (eBay, TCGPlayer, Goldin, PWCC, Heritage) | Yes — opt-in | No | Hard: affiliate links to unwrap | Copy-paste | | **POP report & per-grade sales volume** | Yes | No | You maintain it | No | | **Product images (1600 px)**| Yes | No | You maintain it | Manual saves | | Cost for 1,000 products / month | **≈ $5** | $49 flat | Your dev time + proxies | ~8 hours of your life | | Setup time | 60 seconds | Subscription + coding | Days, breaks on site changes | – | | Export JSON / CSV / Excel / API | Yes, built-in | DIY | DIY | DIY | *** ### Integrate the data - **Exports:** JSON, CSV, Excel, XML from the dataset tab — or fetch programmatically: ``` GET https://api.apify.com/v2/datasets/{datasetId}/items?format=json ``` - **Run on a schedule:** use Apify **Schedules** to re-price daily or weekly, and **webhooks** to push finished runs into your pipeline (Sheets, Slack, your backend). - **From code:** call the Actor with the [Apify API or SDKs](https://docs.apify.com/api) (Python / JavaScript) and read the dataset when the run finishes. - **Run summary:** every run writes a `SUMMARY` record (key-value store) with totals, per-source counts, and the list of failed inputs — ideal for monitoring automated pipelines. *** ### Optional: official API token mode If you have a paid PriceCharting subscription, add your **API token** in the input. When **Scrape full product details** is off, numeric-ID inputs are fetched through PriceCharting's official, sanctioned `/api/product` endpoint (rate-limited to 1 request/second) and marked `"source": "api"`. Note: the official API returns current prices but **no price history and no images**. Because of that, while full details are enabled (the default) the Actor scrapes every input — including numeric IDs — so history and images are never silently missing. URL inputs are always scraped. *** ### FAQ **Which products are supported?** Anything with a PriceCharting product page: video games (every console generation), Pokémon / Magic / Yu-Gi-Oh! / Lorcana / One Piece / Star Wars / Marvel and other TCG cards, comic books, coins, Funko Pops, and LEGO sets. **Do I get product images?** Yes — every scraped record includes the cover (`imageUrl`) and all gallery photos (`images`) as full-resolution 1600 px URLs. **What about graded card prices?** Every card record includes the **complete grading ladder** in `fullPrices`: Ungraded, Grade 1 through 9.5, and the company-specific top grades — **TAG 10, ACE 10, SGC 10, CGC 10, CGC 10 Pristine, PSA 10, BGS 10 and BGS 10 Black Label** — exactly as PriceCharting publishes them. The six headline slots (Ungraded → PSA 10) additionally come with full price **history**; company-specific grades are current market values (the site publishes no time series for them, so this is everything that exists). **Do I get the actual sold listings (comps)?** Yes — turn on **Include recent sold listings** and every record gains `recentSales`: the most recent sales per grade with date, listing title, final sale price (best-offer sales report the accepted price, not the asking price), the marketplace (eBay, TCGPlayer, Goldin, PWCC, Heritage), and a direct, tracking-free link to the listing. Cards also always include `salesVolume` (how many recent sales per grade) and the PSA/CGC `populationReport`. **How fresh is the data?** Each run fetches live pages, so you get exactly what PriceCharting shows at that moment. Schedule the Actor to keep your dataset as fresh as you need. **What happens with broken or wrong URLs?** They're skipped, listed in the run summary with the error, and **never billed**. You pay only for successful product records. **Can I scrape a whole console or set at once?** v1 takes individual product URLs/IDs. Search-keyword and full-set (`/console/…`) modes are on the roadmap — open an issue if you want them prioritized. **Do I need a PriceCharting account?** No. The optional token mode only changes how numeric IDs are fetched. **Are prices in my local currency?** Prices are normalized to **USD** consistently, regardless of run location. **What formats can I export?** JSON, CSV, Excel, XML — from the Console or via the Apify API. *** ### Roadmap & support Planned: search-keyword input, full-set/console bulk mode, per-grade PSA/BGS tables, marketplace (eBay sold) listings. Found a bug or need a field? Open an issue from the Actor's **Issues** tab — feedback directly shapes the roadmap. *** ### Disclaimer This Actor is intended for personal and research use. You are responsible for ensuring your use complies with [PriceCharting's Terms of Service](https://www.pricecharting.com/page/terms-of-service) and applicable law. For high-volume or commercial use, PriceCharting's official paid API (token mode) is the sanctioned data source. Please scrape responsibly — keep concurrency low and delays reasonable. This project is not affiliated with, endorsed by, or sponsored by PriceCharting. # Actor input Schema ## `products` (type: `array`): One entry per line. Each entry is either a full PriceCharting product page URL (e.g. https://www.pricecharting.com/game/super-nintendo/super-mario-world) or a bare numeric product ID (e.g. 7141). ## `scrapeProductDetails` (type: `boolean`): When enabled (default), each product includes its full price history time-series in addition to current prices. Disable for lighter results with current prices only. Product images are included for every scraped product either way. ## `includeRecentSales` (type: `boolean`): Adds 'recentSales' to every product: the most recent sold listings per grade/condition (sale date, listing title, sale price, eBay/TCGPlayer link) — typically up to ~30 per grade. Increases item size; leave off if you only need prices. ## `pricechartingApiToken` (type: `string`): Your PriceCharting API access token. Used only when 'Scrape full product details' is OFF: numeric-ID inputs are then resolved via the official, sanctioned /api/product endpoint (rate-limited to 1 request/second). The official API returns NO price history and NO images, so while full details are enabled (default) all inputs are scraped instead. URL inputs are always scraped. ## `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 parallel page requests. Keep this low to stay respectful of the target site. ## `requestDelaySecs` (type: `integer`): Politeness delay applied before each scrape request. ## `maxItems` (type: `integer`): Stop after producing this many dataset items. Set to 0 for no limit. ## Actor input object example ```json { "products": [ "https://www.pricecharting.com/game/pokemon-base-set/charizard-4", "7141" ], "scrapeProductDetails": true, "includeRecentSales": false, "proxyConfiguration": { "useApifyProxy": true }, "maxConcurrency": 3, "requestDelaySecs": 1, "maxItems": 0 } ``` # Actor output Schema ## `products` (type: `string`): All scraped product records (one item per product). ## `summary` (type: `string`): JSON summary of the run: totals, successes, failures, and counts by source. # 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", "7141" ], "proxyConfiguration": { "useApifyProxy": true } }; // Run the Actor and wait for it to finish const run = await client.actor("incognito_mode/pricecharting-product-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", "7141", ], "proxyConfiguration": { "useApifyProxy": True }, } # Run the Actor and wait for it to finish run = client.actor("incognito_mode/pricecharting-product-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 '{ "products": [ "https://www.pricecharting.com/game/super-nintendo/super-mario-world", "7141" ], "proxyConfiguration": { "useApifyProxy": true } }' | apify call incognito_mode/pricecharting-product-scraper --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "command": "npx", "args": [ "mcp-remote", "https://mcp.apify.com/?tools=incognito_mode/pricecharting-product-scraper", "--header", "Authorization: Bearer " ] } } } ``` ## OpenAPI specification ```json { "openapi": "3.0.1", "info": { "title": "PriceCharting Product Scraper", "description": "Scrape PriceCharting prices for video games, Pokemon and other TCG cards, comics and coins: every grade (PSA, BGS, CGC, SGC, TAG, ACE), full price history, recent sold listings, POP report and 1600px images. Clean JSON/CSV by product URL or ID. Failed lookups are never billed.", "version": "0.1", "x-build-id": "1gKxwDaf8AfqDhQtF" }, "servers": [ { "url": "https://api.apify.com/v2" } ], "paths": { "/acts/incognito_mode~pricecharting-product-scraper/run-sync-get-dataset-items": { "post": { "operationId": "run-sync-get-dataset-items-incognito_mode-pricecharting-product-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-product-scraper/runs": { "post": { "operationId": "runs-sync-incognito_mode-pricecharting-product-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-product-scraper/run-sync": { "post": { "operationId": "run-sync-incognito_mode-pricecharting-product-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": [ "products" ], "properties": { "products": { "title": "Products (URLs or numeric IDs)", "type": "array", "description": "One entry per line. Each entry is either a full PriceCharting product page URL (e.g. https://www.pricecharting.com/game/super-nintendo/super-mario-world) or a bare numeric product ID (e.g. 7141).", "items": { "type": "string" } }, "scrapeProductDetails": { "title": "Scrape full product details (incl. price history)", "type": "boolean", "description": "When enabled (default), each product includes its full price history time-series in addition to current prices. Disable for lighter results with current prices only. Product images are included for every scraped product either way.", "default": true }, "includeRecentSales": { "title": "Include recent sold listings", "type": "boolean", "description": "Adds 'recentSales' to every product: the most recent sold listings per grade/condition (sale date, listing title, sale price, eBay/TCGPlayer link) — typically up to ~30 per grade. Increases item size; leave off if you only need prices.", "default": false }, "pricechartingApiToken": { "title": "PriceCharting API token (optional)", "type": "string", "description": "Your PriceCharting API access token. Used only when 'Scrape full product details' is OFF: numeric-ID inputs are then resolved via the official, sanctioned /api/product endpoint (rate-limited to 1 request/second). The official API returns NO price history and NO images, so while full details are enabled (default) all inputs are scraped instead. URL inputs are always scraped." }, "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 (scrape lane)", "minimum": 1, "maximum": 20, "type": "integer", "description": "Maximum number of parallel page requests. 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 scrape request.", "default": 1 }, "maxItems": { "title": "Max items", "minimum": 0, "type": "integer", "description": "Stop after producing this many dataset items. 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 } } } } } } } } } } ```