# PriceCharting Game Value Guide: Loose, CIB & Graded (`nimbryxo-studio/pricecharting-game-value-guide-loose-cib`) Actor

Search PriceCharting by game title, browse a console's full price list, or look up one game's page, with loose, complete-in-box, new, and graded prices in USD.

- **URL**: https://apify.com/nimbryxo-studio/pricecharting-game-value-guide-loose-cib.md
- **Developed by:** [Nimbryxo-studio](https://apify.com/nimbryxo-studio) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.49 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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?

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 Collector Value Guide: Games, Cards & Comics

PriceCharting is a public price guide for collectibles. This actor turns its guide pages into structured records: current prices by condition or grade, price changes, sales volume, the full price ladder, variants, monthly price history, recent sold listings and catalog metadata. It works across video games, trading cards, comic books, coins, Funko Pop and LEGO sets.

Use it to re-price an inventory, value a collection, compare raw and graded copies, or export a whole console or card set into a spreadsheet or database.

### What this actor does

- Searches PriceCharting by keyword, with optional console, category, region and variant filters.
- Browses every product on a console or set page, following the site's cursor pagination to the end.
- Scrapes one product or a batch of products by page URL or numeric product ID.
- Reads the on-page price table, so each record keeps PriceCharting's own condition or grade labels instead of forcing every category into game-only names.
- Returns the complete on-page price ladder when product pages are read: every grade for cards, every condition for games, coins, comics, LEGO and Funko.
- Adds optional monthly price history, recent sold listings and a console/set value summary.
- Leaves out a field when PriceCharting does not report it for that product. No zeros or placeholders are invented.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `searchGames` | `searchGames` searches by keyword, `consolePrices` browses a console or set, `gameDetails` reads product URLs or IDs. |
| `query` | string | `Super Mario` | Product name, set or keyword to search. |
| `console` | string | empty (all consoles and sets) | Console or set filter for search, or the console/set to browse. |
| `consoleSlug` | string | none | Any PriceCharting console/set slug or URL, including card, comic, coin, Funko and LEGO sets. Overrides `console`. |
| `gameUrl` | string | none | One PriceCharting product page URL or numeric product ID. |
| `productIds` | array | none | More product page URLs or numeric IDs, one per line. |
| `maxItems` | integer | `20` | Maximum records to return. Search mode is capped at 100 by PriceCharting; console mode follows all pages up to this limit. |
| `category` | string | `all` | Search category: `all`, `video-games`, `trading-cards`, `comic-books`, `funko-pops`, `coins` or `lego-sets`. |
| `region` | string | `all` | Search region: `all`, `ntsc`, `pal` or `japan`. |
| `excludeVariants` | boolean | `false` | Skip variants such as Player's Choice, Not for Resale and reprints. |
| `searchSortBy` | string | `popularity` | Search order: `popularity`, `name`, `priceHighToLow` or `biggestChange`. |
| `excludeHardware` | boolean | `false` | Skip consoles, controllers and other hardware when browsing a console or set. |
| `genreName` | string | `all` | Console-mode genre filter, for example `platformer`, `rpg` or `racing`. |
| `consoleSortBy` | string | `popularity` | Console order: `popularity`, `name`, `releaseDate`, `priceHighToLow`, `priceLowToHigh` or `biggestChange`. |
| `releaseDateFilter` | string | `none` | Console release-date filter: `none`, `before` or `after`. |
| `releaseDate` | string | none | Date for the release-date filter, in `YYYY-MM-DD` format. |
| `includeCollectionSummary` | boolean | `false` | Emit one extra record with the console/set value, median price and optional history. |
| `includeDetails` | boolean | `false` | Read every search or console product page for the full price ladder, changes, metadata, variants, history and sales. |
| `includePopulationReport` | boolean | `false` | Fetch the PSA/CGC population report for card products (one extra request per card). |
| `includePriceHistory` | boolean | `false` | Add the monthly price history behind each product chart (product mode or when `includeDetails` is on). |
| `priceHistoryMonths` | integer | `12` | Number of recent monthly history points to keep per condition when history is included. |
| `includeSales` | boolean | `true` | Add recent sold listings with date, title, price, marketplace and link (product mode or when `includeDetails` is on). |
| `salesLimit` | integer | `10` | Number of recent sales to keep per condition when sales are included, up to 30. |

The default input is the smallest useful run: a keyword search for `Super Mario` with 20 records.

#### Example: search all categories

```json
{
  "mode": "searchGames",
  "query": "charizard",
  "category": "trading-cards",
  "maxItems": 20
}
```

#### Example: browse one console, with full product pages and history

```json
{
  "mode": "consolePrices",
  "console": "nintendo-64",
  "consoleSortBy": "name",
  "excludeVariants": true,
  "includeDetails": true,
  "includePriceHistory": true,
  "priceHistoryMonths": 24,
  "maxItems": 50
}
```

#### Example: browse a card set and include the set summary

```json
{
  "mode": "consolePrices",
  "consoleSlug": "pokemon-base-set",
  "includeCollectionSummary": true,
  "includePriceHistory": true,
  "maxItems": 100
}
```

#### Example: one product by URL

```json
{
  "mode": "gameDetails",
  "gameUrl": "https://www.pricecharting.com/game/nintendo-64/super-mario-64",
  "includePriceHistory": true,
  "includeSales": true
}
```

#### Example: a batch of products by ID or URL

```json
{
  "mode": "gameDetails",
  "productIds": [
    "7141",
    "https://www.pricecharting.com/game/pokemon-base-set/charizard-4",
    "https://www.pricecharting.com/game/coins-lincoln-wheat-penny/1909-s-vdb"
  ],
  "includePriceHistory": true,
  "salesLimit": 5
}
```

### Output

Every record has `recordType` set to `product`, `listing` or `collection`.

| Field | Description |
|---|---|
| `recordType` | `product` for a full product page, `listing` for a search or console row, `collection` for a console/set summary. |
| `title` | Product name. |
| `productId` | PriceCharting numeric product ID. |
| `slug` | Product URL slug. |
| `gameUrl` | Canonical product page URL. |
| `consoleName` | Console, set or series name. |
| `consoleSlug` | Console or set slug. |
| `consoleUrl` | Console or set page URL. |
| `consoleUid` | PriceCharting console UID when available. |
| `category` | PriceCharting category, for example `video-games`, `pokemon-cards`, `coins` or `comic-books`. |
| `loosePrice` | First headline price slot: loose for games, ungraded for cards/comics/coins, out of box for Funko, pieces only for LEGO. |
| `cibPrice` | Second headline slot: complete for games, Grade 7 for cards, mid grade for comics and coins. |
| `newPrice` | Third headline slot: new/sealed for games, Grade 8 for cards, higher grade for comics and coins. |
| `gradedPrice` | Fourth headline slot: graded for games, Grade 9 for cards, high grade for comics and coins. |
| `boxOnlyPrice` | Fifth headline slot, where the category uses one. |
| `manualOnlyPrice` | Sixth headline slot, where the category uses one. |
| `gradedCibPrice` | Video-game full-guide row for graded complete-in-box. |
| `gradedNewPrice` | Video-game full-guide row for graded new/sealed. |
| `itemBoxPrice` | Video-game full-guide row for item and box. |
| `itemManualPrice` | Video-game full-guide row for item and manual. |
| `prices` | Array of the headline conditions with `condition`, `label`, `price`, `change`, `salesVolume` and `salesPerDay`. The label is the site's own wording. |
| `priceChanges` | Price change since the last update, keyed by headline slot. Negative values are drops. |
| `salesVolumes` | Sales-volume text keyed by headline slot, for example `5 sales per day`. |
| `salesPerDay` | Normalized sales per day keyed by headline slot. |
| `fullPrices` | Every row of the on-page Full Price Guide, keyed by the site's own label. For cards this includes every grading company and grade. |
| `priceHistory` | Monthly points `{date, price}` keyed by headline slot. Months with no tracked price are omitted. |
| `priceHistoryLabels` | The site's condition/grade label for each price-history slot. |
| `sales` | Recent sold listings: `condition`, `conditionLabel`, `date`, `title`, `price`, optional `listedPrice`, `source` and optional `url` (eBay, Goldin and Fanatics/PWCC links are derived; some Heritage sales have no stable item URL). |
| `variants` | Variant links with `title`, `url` and optional `productId`. |
| `imageUrl` | Main product image URL. |
| `imageUrlHiRes` | 1600px version of the main product image. |
| `imageUrls` | Gallery image URLs when more than one is available. |
| `releaseDate` | Release date in ISO format when PriceCharting lists one. |
| `genre` | Genre, series or category label from the product details. |
| `publisher` | Publisher or manufacturer. |
| `developer` | Developer. |
| `esrbRating` | ESRB rating for video games. |
| `modelNumber` | Model or set number. |
| `playerCount` | Player count. |
| `upc` | UPC. |
| `asin` | Amazon ASIN. |
| `epid` | eBay ePID. |
| `cardNumber` | Card number. |
| `printRun` | Print run. |
| `description` | Product description when PriceCharting has one. |
| `attributes` | All product-detail label/value pairs with camelCase keys. |
| `populationReportUrl` | PSA/CGC population page URL when the product has one (cards). |
| `populationReport` | Card population data: `grades` (PSA/CGC/total/price per grade), `totals` and optional monthly `history`. |
| `collectionName` | Collection record only: console or set name. |
| `collectionSlug` | Collection record only: console or set slug. |
| `collectionUrl` | Collection record only: console or set URL. |
| `productCount` | Collection record only: number of products in the set. |
| `collectionValue` | Collection record only: current PriceCharting index value in USD. |
| `collectionMedian` | Collection record only: current median price in USD. |
| `priceHistory` | Collection record only: `value` and `median` monthly series when history is enabled. |
| `enriched` | `true` when a listing row was enriched by reading its product page. |
| `scrapedAt` | UTC timestamp of the scrape. |

#### Headline price slots by category

PriceCharting reuses the same six price columns with different labels for each category. The `prices` array always carries the real label; the six flat fields are stable slots for integrations.

| Slot | Video games | Trading cards | Comics | Coins | Funko Pop | LEGO |
|---|---|---|---|---|---|---|
| `loosePrice` | Loose | Ungraded | Ungraded | Ungraded | Out of Box | Pieces Only |
| `cibPrice` | Complete | Grade 7 | 4.0 / VG | VF | In Dmg Box | Complete |
| `newPrice` | New | Grade 8 | 6.0 / Fine | AU | New | New |
| `gradedPrice` | Graded | Grade 9 | 8.0 / VF | MS62 | - | Pieces & Manual |
| `boxOnlyPrice` | Box Only | Grade 9.5 | 9.2 / NM- | MS64 | - | Box Only |
| `manualOnlyPrice` | Manual Only | PSA 10 | 9.8 | MS66 | - | Manual Only |

Read `prices[].label` or `fullPrices` when you need the exact condition or grade name for a category.

### Use cases

- **Resale pricing** â€” check loose, complete, sealed and graded values before buying or listing a collection.
- **Collection valuation** â€” run a console or set and sum the current guide values.
- **Grading research** â€” compare ungraded and high-grade prices to estimate whether grading is worthwhile.
- **Market tracking** â€” rerun the same products on a schedule and compare `priceChanges` and `priceHistory`.
- **Catalog enrichment** â€” export metadata, images, variants, UPC/ASIN/ePID and full grade ladders for a storefront or database.

### FAQ

**Do I need an account or API key?**
No. The actor reads public PriceCharting pages. It does not use the paid PriceCharting API and needs no cookies, token or proxy setup.

**What currency are prices in?**
US dollars, matching PriceCharting's guide. Some pages show a local-currency conversion in the browser, but the guide values used here are USD.

**Why are the six flat price fields null or missing for some categories?**
Because PriceCharting does not price that many conditions for every category. The `prices` array and `fullPrices` object contain exactly what the page reports; empty fields are omitted.

**Why does a search return at most 100 products?**
PriceCharting caps its search results at 100. Use console/set browsing for complete lists, or narrow the search with a console, category or region filter.

**How many products can console mode return?**
All of them. The site shows 150 products per page and the actor follows its cursor until the set ends or `maxItems` is reached.

**Does the actor return price history for every product?**
Only when `includePriceHistory` is on and PriceCharting has chart data. History is monthly and goes back as far as PriceCharting tracked the item.

**Are the sold listings included?**
Yes, when product pages are read and `includeSales` is on. PriceCharting shows up to 30 recent sales per condition; `salesLimit` controls how many are kept. eBay, Goldin and Fanatics/PWCC links are derived; some Heritage sales have no stable item URL.

**Can I get card population data?**
Yes. Set `includePopulationReport` with product pages or `includeDetails`; card products get a `populationReport` with PSA/CGC counts per grade, totals and recent population history.

**Why did the actor use a reader mirror?**
PriceCharting runs a Cloudflare challenge on some networks. The actor first tries the site directly, then a cookieless reader mirror so a run can still complete without cookies or a browser. No user credentials are sent to either path.

**Is this affiliated with PriceCharting?**
No. This is an unofficial tool that reads publicly accessible pages. PriceCharting is the source of the guide values; link back to the product page when you display them.

### Limitations

- Search results are capped at 100 per query by the source. Narrow by category, region or console, or use console/set browsing for complete lists.
- Some Heritage auction sales have no stable item URL; their date, title, price and source are still returned.
- Price history is the monthly chart series, capped by PriceCharting at 240 monthly points, not individual sales.
- The six headline slots are positional and need the category mapping above for non-video-game products.
- Prices are guide values calculated by PriceCharting from completed sales, not a guarantee of a future sale price.

# Actor input Schema

## `mode` (type: `string`):

What to scrape.

## `query` (type: `string`):

Product name, set or keyword to search (search mode).

## `console` (type: `string`):

Filter search results to one console, or choose the console/set to browse. Leave empty to search all consoles.

## `consoleSlug` (type: `string`):

Any PriceCharting console/set slug or URL, including card, comic, coin, Funko and LEGO sets (for example pokemon-base-set). Overrides the Console or set field.

## `gameUrl` (type: `string`):

One product page URL or numeric product ID (product mode). Example: https://www.pricecharting.com/game/nintendo-64/super-mario-64

## `productIds` (type: `array`):

More product page URLs or numeric IDs, one per line (product mode).

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

Maximum records to return. Search mode is capped at 100 by PriceCharting; console mode follows all pages.

## `category` (type: `string`):

Narrow search results to one collectible category.

## `region` (type: `string`):

Narrow search results to a release region.

## `excludeVariants` (type: `boolean`):

Skip variants such as Player's Choice, Not for Resale and reprints.

## `searchSortBy` (type: `string`):

Order of search results.

## `excludeHardware` (type: `boolean`):

Skip consoles, controllers and other hardware when browsing a console or set.

## `genreName` (type: `string`):

Only include products in this genre (console mode).

## `consoleSortBy` (type: `string`):

Order of products on a console or set page.

## `releaseDateFilter` (type: `string`):

Keep products released before or after a date (console mode).

## `releaseDate` (type: `string`):

Date for the release date filter, in YYYY-MM-DD format.

## `includeCollectionSummary` (type: `boolean`):

Emit one extra record with the console/set value, median price and optional history (console mode).

## `includeDetails` (type: `boolean`):

Open each search or console product page for the full price guide, price changes, metadata, variants, history and sales. Slower and more requests.

## `includePopulationReport` (type: `boolean`):

Fetch the PSA/CGC population report for card products (one extra request per card).

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

Add the monthly price history behind each product chart (product mode or when Read every product page is on).

## `priceHistoryMonths` (type: `integer`):

How many recent monthly points to keep per condition.

## `includeSales` (type: `boolean`):

Add recent sold listings with date, title, price, marketplace and link (product mode or when Read every product page is on). Up to 30 per condition.

## `salesLimit` (type: `integer`):

How many recent sales to keep for each condition when sales are included.

## Actor input object example

```json
{
  "mode": "searchGames",
  "query": "Super Mario",
  "console": "",
  "maxItems": 20,
  "category": "all",
  "region": "all",
  "excludeVariants": false,
  "searchSortBy": "popularity",
  "excludeHardware": false,
  "genreName": "all",
  "consoleSortBy": "popularity",
  "releaseDateFilter": "none",
  "includeCollectionSummary": false,
  "includeDetails": false,
  "includePopulationReport": false,
  "includePriceHistory": false,
  "priceHistoryMonths": 12,
  "includeSales": true,
  "salesLimit": 10
}
```

# Actor output Schema

## `games` (type: `string`):

Dataset of product and console/set records. Product records include prices, fullPrices, priceChanges, salesVolumes, variants, metadata, and optional priceHistory and sales.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "mode": "searchGames",
    "query": "Super Mario",
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("nimbryxo-studio/pricecharting-game-value-guide-loose-cib").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "mode": "searchGames",
    "query": "Super Mario",
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("nimbryxo-studio/pricecharting-game-value-guide-loose-cib").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 '{
  "mode": "searchGames",
  "query": "Super Mario",
  "maxItems": 20
}' |
apify call nimbryxo-studio/pricecharting-game-value-guide-loose-cib --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nimbryxo-studio/pricecharting-game-value-guide-loose-cib"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/A8EpcQIQcH3TzAlBm/builds/7pe5dcE1auzlc3JSQ/openapi.json
