# PriceCharting Product Scraper (`parsebird/pricecharting-product-scraper`) Actor Scrape PriceCharting product data: current prices for every condition and grade, full price history, PSA/BGS/CGC values, POP report, recent sold listings, and images. Export as JSON, CSV, Excel. - **URL**: https://apify.com/parsebird/pricecharting-product-scraper.md - **Developed by:** [ParseBird](https://apify.com/parsebird) (community) - **Categories:** E-commerce, Developer tools - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks - **User rating**: No ratings yet ## Pricing from $1.50 / 1,000 products This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events. Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have. Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event ## What's an Apify Actor? Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows. 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. - **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use). - **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`. - **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`. - **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`. - **Any other language** — 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 Scrape **PriceCharting** product data by page URL or product ID — current prices for every condition and grade, the full month-by-month **price history**, PSA / BGS / CGC / SGC graded values, the graded **POP report**, per-grade sales volume, recent sold listings, and full-resolution images.
Paste PriceCharting product URLs or numeric IDs and get back structured pricing for games, trading cards, comics, coins, Funko Pops, and LEGO sets — 20+ fields per product including a stable six-slot price mapping, the complete on-page price guide with every grading company, per-condition price-history series, and opt-in eBay / TCGPlayer / Goldin / PWCC / Heritage sold listings.
##### Copy to your AI assistant Copy this block into ChatGPT, Claude, Cursor, or any LLM to start using this actor. ``` Actor: parsebird/pricecharting-product-scraper — Scrape PriceCharting product prices, price history, graded values, POP report, and recent sales. Usage: from apify_client import ApifyClient; client = ApifyClient("YOUR_TOKEN"); run = client.actor("parsebird/pricecharting-product-scraper").call(run_input={"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}) Inputs: products (array, required — one product page URL or numeric product ID per line), scrapeProductDetails (bool, default true — include the full priceHistory series), includeRecentSales (bool, default false — adds recentSales, ~5x item size), priceChartingToken (string, secret, optional — resolves numeric IDs via the official API when details are off), proxyConfiguration (object, default Apify datacenter), maxConcurrency (int, default 3), requestDelaySecs (int, default 1, max 10), maxItems (int, default 0 = unlimited) Output fields: productId, productName, consoleName, category, url, releaseDate, genre, upc, epid, asin, imageUrl, images, flags, currency, prices {loose,cib,new,graded,boxOnly,manualOnly}, fullPrices (verbatim on-page labels), salesVolume, populationReport (cards: PSA & CGC per grade 1-10), recentSales (opt-in), priceHistory (per condition: {date, price}), source (scrape|api), scrapedAt Failures: unfetched inputs are not billed and are listed in the run's SUMMARY key-value record. API spec: https://apify.com/parsebird/pricecharting-product-scraper/api Get token: https://console.apify.com/account/integrations ``` ### What is PriceCharting Product Scraper? **PriceCharting Product Scraper** turns any [PriceCharting](https://www.pricecharting.com) product page into structured JSON. Give it a list of product page URLs or numeric product IDs and it returns current market prices for every condition slot, the complete on-page price guide (with **PSA 10**, **BGS 10**, **CGC 10**, **SGC 10**, plus Black Label and Pristine variants for cards), the full price-history time series, the graded population report, and — when you ask for it — the recent sold listings behind those prices. It works as a **PriceCharting API alternative**: the official [PriceCharting API](https://www.pricecharting.com/api-documentation) needs a paid subscription and returns only current prices with no history, no images, and no sold listings. This scraper needs no subscription and returns all of it. If you *do* have a subscription, drop your token in and it will resolve numeric IDs through the official API when you only need current prices. ### What can PriceCharting Product Scraper do? - 💲 **Current prices** for all six PriceCharting condition/grade slots, with a stable key mapping you read per category (see the table below) - 📊 **Full price guide** (`fullPrices`) — every row of the on-page guide with labels exactly as shown: for cards that means Ungraded, Grade 1 … Grade 9.5, then TAG 10, ACE 10, SGC 10, CGC 10, PSA 10, BGS 10, BGS 10 Black, CGC 10 Pristine; for games Loose, Complete, Graded CIB, and more - 📈 **Price history** (`priceHistory`) — the month-by-month series behind every chart, one array of `{ date, price }` points per condition - 🏆 **Population report** (`populationReport`) — PSA and CGC population counts per grade 1–10 for cards - 🧾 **Recent sold listings** (`recentSales`, opt-in) — up to ~30 sold listings per grade with date, title, price, marketplace (eBay, TCGPlayer, Goldin, PWCC, Heritage), item ID, and link - 🖼️ **Images** — cover photo plus the full gallery (card backs, box / cart / manual shots) at 1600 px - 🏷️ **Catalog metadata** — category, release date, genre, UPC, ASIN, eBay ePID, and product-type flags (`isCard`, `isComic`, `isCoin`, `isSystem`, `isLegoSet`, `isFunkoPop`, …) - 🔀 Works across **video games, trading cards, comics, coins, Funko Pops, and LEGO sets** — the same six slots, labelled per the on-site convention - 🗂️ **Failure report** — inputs that can't be fetched are never billed and are listed in the run's `SUMMARY` key-value record so you can inspect and retry them ### What data can you extract from PriceCharting? | 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`, `lego-sets`) | | `url` | Canonical product page URL | | `releaseDate`, `genre`, `upc`, `epid`, `asin` | Catalog metadata where available | | `imageUrl` / `images` | Cover photo and full gallery, 1600 px | | `flags` | Product-type booleans: `isCard`, `isComic`, `isCoin`, `isSystem`, `isFunkoPop`, `isLegoSet`, … | | `currency` | Always `USD` | | `prices` | Current price per condition slot — `loose`, `cib`, `new`, `graded`, `boxOnly`, `manualOnly` | | `fullPrices` | Every row of the on-page Full Price Guide, labels verbatim (`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 | | `recentSales` | Opt-in: recent sold listings per grade — `{ date, title, price, source, itemId, url }` | | `priceHistory` | Per-condition arrays of `{ date, price }` 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 | LEGO sets | |-----|-------------|---------------|-----------| | `prices.loose` | Loose (cart / disc only) | Ungraded | Pieces only | | `prices.cib` | Complete in box | Grade 7 | Complete | | `prices.new` | New / sealed | Grade 8 | New / sealed | | `prices.graded` | Graded | Grade 9 | Pieces & manual | | `prices.boxOnly` | Box only | Grade 9.5 | Box only | | `prices.manualOnly` | Manual only | PSA 10 | Manual only | `priceHistory` uses these same keys, with one exception: the Ungraded / Loose series is under **`used`** (not `loose`). So for a card, `priceHistory.manualOnly` is the PSA 10 price over time and `priceHistory.used` is the Ungraded price over time. If the six slots aren't enough, read **`fullPrices`** instead — it carries the site's complete price guide with the labels exactly as shown on the page, and for cards it includes every grading company (TAG / ACE / SGC / CGC / PSA / BGS, plus Black Label and Pristine variants). Price 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. ### How to scrape PriceCharting 1. Open [PriceCharting Product Scraper](https://apify.com/parsebird/pricecharting-product-scraper) on Apify Store and click **Try for free**. 2. In **Products**, add one product per line: a full product page URL (e.g. `https://www.pricecharting.com/game/pokemon-base-set/charizard-4`) or a numeric product ID (e.g. `7141`). 3. Leave **Scrape full product details** on to get the price-history series, or turn it off if you only need current prices. 4. Turn on **Include recent sold listings** if you need the individual sales behind each grade (this makes each record roughly 5x larger). 5. Leave **Proxy configuration** on Automatic — Apify datacenter proxies are reliable here and the cheapest option. 6. Click **Start**, then download the results as JSON, CSV, Excel, or XML, or pull them through the API. ### Input parameters | Parameter | Type | Required | Default | Description | |-----------|------|----------|---------|-------------| | `products` | array | **Yes** | — | One product page URL or numeric product ID per line | | `scrapeProductDetails` | boolean | No | `true` | Include the full `priceHistory` series. Images and current prices are always included for scraped products | | `includeRecentSales` | boolean | No | `false` | Add `recentSales` (up to ~30 sold listings per grade). Increases item size ~5x | | `priceChartingToken` | string (secret) | No | — | Optional PriceCharting API token. Resolves numeric IDs through the official API when full details are off | | `proxyConfiguration` | object | No | Apify datacenter | Proxy used for scraping. Switch to residential only if you see repeated failed requests | | `maxConcurrency` | integer | No | `3` | Parallel requests (kept low to be respectful) | | `requestDelaySecs` | integer | No | `1` | Politeness delay in seconds between requests (max 10) | | `maxItems` | integer | No | `0` | Stop after N results (`0` = unlimited) | #### Input 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 } ``` ### Output example ```json { "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", "genre": "Pokemon Card", "upc": null, "epid": null, "asin": null, "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, "isLegoSet": false, "isFunkoPop": false }, "currency": "USD", "prices": { "loose": 437.00, "cib": 772.69, "new": 1312.50, "graded": 2909.38, "boxOnly": 7397.73, "manualOnly": 26566.47 }, "fullPrices": { "Ungraded": 437.00, "Grade 7": 772.69, "Grade 8": 1312.50, "Grade 9": 2909.38, "Grade 9.5": 7397.73, "TAG 10": null, "ACE 10": null, "SGC 10": 15940.00, "CGC 10": 7040.65, "PSA 10": 26566.47, "BGS 10": 34536.00, "BGS 10 Black": 172680.00, "CGC 10 Pristine": 20800.00 }, "salesVolume": { "Ungraded": 59, "PSA 10": 30, "CGC 10": 30, "Grade 9": 30 }, "populationReport": { "PSA": { "1": 4096, "2": 3573, "9": 8455, "10": 486 }, "CGC": { "8": 1, "9": 2, "10": 4 } }, "priceHistory": { "used": [ { "date": "2020-12-01", "price": 225.00 }, { "date": "2021-01-01", "price": 282.40 } ], "manualOnly": [ { "date": "2020-12-01", "price": 9800.00 } ] }, "source": "scrape", "scrapedAt": "2026-08-26T04:24:21+00:00" } ``` With **Include recent sold listings** on, each record also carries: ```json "recentSales": { "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..." } ] } ``` Download every run in **JSON, CSV, Excel, or XML** from the dataset tab or the API. ### Use cases - 📉 **Price monitoring** — schedule a daily run over your watchlist and track the six price slots plus PSA 10 / BGS 10 over time - 💼 **Collection valuation** — value a whole collection at once by feeding a list of product IDs - 🃏 **Card grading decisions** — compare Ungraded vs PSA 10 vs BGS 10 spreads and pull the POP report to gauge scarcity before submitting a card - 🛒 **Reseller sourcing** — cross-check a listing against `recentSales` from eBay, Goldin, PWCC, and Heritage - 📚 **Dataset building** — build a structured price database for games, cards, comics, or LEGO sets with full history - 🤖 **AI agent tooling** — give an LLM live PriceCharting values through the Apify API or MCP ### How it works 1. Each line in `products` is resolved to a product page: numeric IDs become `pricecharting.com/game/`, URLs are used as-is. 2. Pages are fetched through Apify proxies with browser-grade TLS fingerprinting and a small politeness delay; anti-bot challenges are retried with backoff on a rotated IP. 3. The page's embedded price data, chart series, population data, and sold-listing tables are parsed into the fields above — no data is invented, and a field with no value on the page is returned as `null`. 4. When **Scrape full product details** is off and a PriceCharting API token is supplied, numeric IDs are resolved through the official `/api/product` endpoint instead (`source: "api"`). 5. Records are pushed to the dataset as they're scraped; failures are collected into the `SUMMARY` key-value record and the run's status message reports how many succeeded. ### How much does it cost to scrape PriceCharting? This actor uses one pay-per-event billable: | Event | Free | Bronze | Silver | Gold | |-------|------|--------|--------|------| | `product-scraped` (per product saved) | $0.003 / **$3.00** per 1,000 | $0.0025 / **$2.50** per 1,000 | $0.002 / **$2.00** per 1,000 | $0.0015 / **$1.50** per 1,000 | Scraping 1,000 products costs about **$3** on the Free tier, dropping to **$1.50** on Gold. Inputs that fail to fetch are not saved and **not billed**. Apify's monthly free platform credits are enough to test the actor. Platform compute is included in the event price — you only pay for saved products. ### Comparison to the alternatives | Capability | This actor | Official API ($49/mo) | Roll your own | Manual lookups | |---|---|---|---|---| | Current prices, every condition | ✅ | ✅ | ⚠️ you maintain it | 🐌 one at a time | | Month-by-month price history | ✅ | ❌ | ⚠️ reverse-engineer the charts | ❌ | | Graded values — PSA / BGS / CGC / SGC / TAG / ACE (incl. Black Label, Pristine) | ✅ `fullPrices` | ❌ | ⚠️ you maintain it | 🐌 one grade at a time | | Recent sold listings (eBay, TCGPlayer, Goldin, PWCC, Heritage) | ✅ opt-in | ❌ | ⚠️ affiliate links to unwrap | ✂️ copy-paste | | POP report & per-grade sales volume | ✅ | ❌ | ⚠️ you maintain it | ❌ | | Product images (1600 px) | ✅ | ❌ | ⚠️ you maintain it | 💾 manual saves | | Cost for 1,000 products / month | **≈ $3** (≈ $1.50 on Gold) | $49 flat | your dev time + proxies | hours of your life | | Setup time | ~60 seconds | subscription + coding | days, breaks on site changes | — | | Export JSON / CSV / Excel / API | ✅ built-in | DIY | DIY | DIY | ### Integrations and API access PriceCharting Product Scraper runs on the [Apify platform](https://apify.com), which gives you: - **Scheduling** — run daily, weekly, or on any custom [schedule](https://docs.apify.com/platform/schedules) - **API access** — start runs and fetch results programmatically ([API reference](https://apify.com/parsebird/pricecharting-product-scraper/api)) - **Webhooks & integrations** — connect to Google Sheets, Slack, Zapier, Make, and [more](https://docs.apify.com/platform/integrations) - **Export formats** — JSON, CSV, Excel, or XML #### Python example ```python from apify_client import ApifyClient client = ApifyClient("YOUR_API_TOKEN") run = client.actor("parsebird/pricecharting-product-scraper").call(run_input={ "products": [ "https://www.pricecharting.com/game/pokemon-base-set/charizard-4", "7141", ], "scrapeProductDetails": True, "includeRecentSales": False, "proxyConfiguration": {"useApifyProxy": True}, }) for item in client.dataset(run["defaultDatasetId"]).iterate_items(): p = item["prices"] print(f"{item['productName']} ({item['consoleName']}) — loose {p['loose']} / graded {p['graded']}") ``` #### JavaScript example ```javascript import { ApifyClient } from 'apify-client'; const client = new ApifyClient({ token: 'YOUR_API_TOKEN' }); const run = await client.actor('parsebird/pricecharting-product-scraper').call({ products: [ 'https://www.pricecharting.com/game/pokemon-base-set/charizard-4', '7141', ], scrapeProductDetails: true, includeRecentSales: false, proxyConfiguration: { useApifyProxy: true }, }); const { items } = await client.dataset(run.defaultDatasetId).listItems(); items.forEach(i => console.log(`${i.productName}: loose ${i.prices.loose} / graded ${i.prices.graded}`)); ``` ### Is it legal to scrape PriceCharting? Scraping publicly available data is generally legal, as reaffirmed by the US Ninth Circuit in *hiQ Labs v. LinkedIn* (2022). PriceCharting Product Scraper reads only publicly visible information from [PriceCharting](https://www.pricecharting.com) product pages — the same data any visitor sees without logging in — and does not access private accounts or bypass authentication or payment systems. You are responsible for making sure your use case complies with applicable laws and with [PriceCharting's terms of use](https://www.pricecharting.com/terms). For more background, see [Apify's guide to web scraping and the law](https://blog.apify.com/is-web-scraping-legal/). ### Related actors - [eBay Sold Listings Scraper](https://apify.com/parsebird/ebay-sold-listings-scraper) — real sold prices from eBay across 8 marketplaces - [Vinted Scraper](https://apify.com/parsebird/vinted-scraper) — prices and listings from the Vinted secondhand marketplace - [AliExpress Scraper](https://apify.com/parsebird/aliexpress-scraper) — product prices, ratings, and variants from AliExpress - [Data Cleaner](https://apify.com/parsebird/data-cleaner) — clean, filter, and reshape any Apify dataset - [Data Deduplicator](https://apify.com/parsebird/dataset-deduplicator) — remove duplicate records from any Apify dataset ### FAQ **Do I need a PriceCharting subscription or API token?** No. The scraper works on public product pages without any account. A token is only useful if you already pay for PriceCharting and want numeric IDs resolved through the official API when `scrapeProductDetails` is off. **What's the difference between `prices` and `fullPrices`?** `prices` is the stable six-slot mapping (`loose`, `cib`, `new`, `graded`, `boxOnly`, `manualOnly`) you read per category. `fullPrices` is every row of the on-page price guide with the site's own labels — for cards that includes each grading company (PSA, BGS, CGC, SGC, TAG, ACE, plus Black Label and Pristine). **Why is `priceHistory` missing some grades?** PriceCharting only publishes a time series for the six main slots. Company-specific card grades (BGS 10, CGC 10 Pristine, …) have a current value in `fullPrices` but no history. **Why are `upc`, `epid`, or `asin` sometimes `null`?** Those fields only exist for products PriceCharting has catalogued with them — common for modern games, rare for vintage cards. When the page doesn't show a value, the field is `null` rather than guessed. **How do I get the recent sold listings?** Turn on **Include recent sold listings**. Each record then gets a `recentSales` object keyed by grade, with up to ~30 sales each (`date`, `title`, `price`, `source`, `itemId`, `url`). It roughly 5x's item size, so leave it off if you only need prices. **Some of my inputs didn't come back — where are they?** Failed inputs are never written to the dataset and never billed. Open the run's key-value store and read the `SUMMARY` record — it lists every failure with the input and the reason so you can fix and retry. **What proxy should I use?** Leave it on Automatic (Apify datacenter) — it's reliable for PriceCharting and the cheapest option. Switch to residential only if you start seeing failed requests in the `SUMMARY` record. **Can I schedule recurring runs?** Yes. Use [Apify's scheduling](https://docs.apify.com/platform/schedules) to run daily or weekly, and pair it with webhooks or integrations to push new prices into Google Sheets, a database, or Slack. Found a bug or missing field? Open an issue on the actor's **Issues** tab. # Actor input Schema ## `products` (type: `array`): One product per line: a PriceCharting product page URL (e.g. https://www.pricecharting.com/game/pokemon-base-set/charizard-4) or a numeric product ID (e.g. 7141). The ID appears in the URL bar and by hovering the product title on PriceCharting. ## `scrapeProductDetails` (type: `boolean`): Include the full month-by-month price-history series for every condition. Images, current prices, and the full price guide are always included for scraped products. Turn off if you only need current prices. ## `includeRecentSales` (type: `boolean`): Add recentSales: up to ~30 recent sold listings per grade/condition, each with date, title, price, marketplace, and link. Increases item size roughly 5x, so leave off if you only need prices. ## `priceChartingToken` (type: `string`): Optional. If you have a paid PriceCharting subscription, paste your 40-character API token here. It is used only to resolve numeric product IDs through the official API when "Scrape full product details" is off. URL inputs are always scraped. ## `proxyConfiguration` (type: `object`): Proxy used for scraping. Automatic (Apify datacenter) is reliable and the cheapest option. Switch to residential only if you see repeated failed requests. ## `maxConcurrency` (type: `integer`): How many product pages to request in parallel. Kept low to be respectful to PriceCharting. ## `requestDelaySecs` (type: `integer`): Politeness delay, in seconds, between requests on the same worker. ## `maxItems` (type: `integer`): Stop after this many products have been saved to the dataset. 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 ## `dataset` (type: `string`): No description # 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/pokemon-base-set/charizard-4", "7141" ], "proxyConfiguration": { "useApifyProxy": true } }; // Run the Actor and wait for it to finish const run = await client.actor("parsebird/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/pokemon-base-set/charizard-4", "7141", ], "proxyConfiguration": { "useApifyProxy": True }, } # Run the Actor and wait for it to finish run = client.actor("parsebird/pricecharting-product-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/pokemon-base-set/charizard-4", "7141" ], "proxyConfiguration": { "useApifyProxy": true } }' | apify call parsebird/pricecharting-product-scraper --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com/?tools=fetch-actor-details,parsebird/pricecharting-product-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/i1j4nVfMvGkOpXzaH/builds/wWImXGBsJDOt9zw0u/openapi.json