# TCGplayer Card Price Scraper — 8 TCGs · No Cap (`gio21/tcgplayer-scraper`) Actor

Search TCGplayer across 8 TCGs (Pokemon, Magic, Yu-Gi-Oh, Lorcana & more) for product prices or live seller listings with condition, printing, language & seller rating. No cap on results. $0.003/item.

- **URL**: https://apify.com/gio21/tcgplayer-scraper.md
- **Developed by:** [Gio](https://apify.com/gio21) (community)
- **Categories:** E-commerce
- **Features:** Limited permissions
- **Stats:** 11 total users, 3 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$3.00 / 1,000 result items

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

## TCGplayer Card Price Scraper — 8 TCGs · No Cap

### Why use this scraper

TCGplayer prices move hour to hour: a single bulk buy, a tournament result, or a reprint announcement can shift a card's market price by double digits in a day. Anyone buying or selling cards at volume (shop owners restocking, flippers hunting undervalued listings, collection appraisers, price-tracking apps) needs a feed of what cards actually cost right now, not a cached number from last week.

Pulling this by hand means opening TCGplayer, searching one card at a time, and manually reading market price, median price, and the cheapest live listings off the page. For a shop with a few hundred SKUs, or a flipper scanning a few thousand cards a day, that does not scale. This scraper turns a search query (or a batch of them) into structured JSON: product-level price summaries, or, when you need it, every individual seller listing for a card, with seller rating, condition, printing, and shipping cost included.

### Overview

Give it a search query (a card name, a product name, or a batch of several) and a game, and it returns one record per matching product, or, when "Include seller listings" is on, one record per individual seller listing for the top matches, sorted by total price. Output includes product ID, name, set, collector number, rarity, market and median price, and, in listings mode, seller name, rating, sales count, verified/gold/direct-seller badges, condition, printing, language, item price, shipping, and total price. A typical run of 20 to 50 items finishes in under a minute; a listings run that opens several products takes longer because each product page is fetched individually.

### Supported inputs

- **Single search query** — `query`: one card or product name (e.g. "Charizard ex", "Black Lotus"). Searches the selected game's TCGplayer catalog.
- **Multiple search queries** — `queries`: a list of search terms run in one call; takes precedence over `query` when both are set. Use this to price out a whole want-list or a restock sheet in one run.
- **Game filter** — `game`: pick one of 8 supported trading card games (Pokemon, Magic: The Gathering, Yu-Gi-Oh!, Disney Lorcana, One Piece, Flesh and Blood, Digimon, Star Wars Unlimited), or `all` to search across every game on TCGplayer at once.
- **Sort order** — `sortOption`: best match, price ascending/descending, best selling, newest, or name A-Z, matching the sort options on the TCGplayer search page itself.
- **Seller listings mode** — `includeListings: true` switches from product-level price summaries to individual seller listings, with `condition`, `printing`, `language`, `maxProducts` (how many matched products to open) and `maxListingsPerProduct` to control scope and cost.

### Use cases

- **Card shop owners** pricing restock sheets against the live market before placing a bulk buy order, instead of checking each card by hand.
- **Flippers and arbitrage sellers** scanning for listings priced well under market or median, filtered by condition and printing, to resell at a margin.
- **Collection appraisers and insurers** pulling current market and median price for a list of cards to value a collection at a point in time.
- **Price-tracking apps and spreadsheets** refreshing a watchlist of cards daily or weekly without a human opening TCGplayer.
- **Deck builders and tournament players** comparing the cheapest legal printing of a card (foil vs normal, which language) before buying singles for a deck.

### How it works

The scraper requests TCGplayer's own search and product pages for the query and game you give it, the same pages a shopper's browser would load, and parses the structured price and listing data already embedded in the page rather than guessing from visible text. In product mode it reads the market price, median price, and listing count straight off the search result; in listings mode it opens each matched product's page and reads every individual seller row (price, shipping, condition, printing, language, seller reputation) in the order TCGplayer itself ranks them. No login or session is required for either mode, since TCGplayer serves price data on public pages.

### Input configuration — 3 examples

**1. Quick price check on one card:**

```json
{
  "query": "Charizard ex",
  "game": "pokemon",
  "maxItems": 20
}
```

**2. Batch price-out of a want-list across games:**

```json
{
  "queries": ["Black Lotus", "Mox Sapphire", "Time Walk"],
  "game": "magic",
  "sortOption": "price-desc",
  "maxItems": 50
}
```

**3. Live seller listings for arbitrage, Near Mint only:**

```json
{
  "query": "Charizard ex",
  "game": "pokemon",
  "includeListings": true,
  "condition": "Near Mint",
  "maxProducts": 5,
  "maxListingsPerProduct": 20
}
```

### Output sample

Product mode (real output, `query=Lightning Bolt`, `game=magic`):

```json
{
  "productId": 35427,
  "name": "Lightning Bolt",
  "set": "Magic 2011 (M11)",
  "number": "149",
  "rarity": "Common",
  "game": "Magic: The Gathering",
  "marketPrice": 1.08,
  "medianPrice": 1.21,
  "query": "Lightning Bolt",
  "scrapedAt": "2026-10-22T22:43:10.858Z"
}
```

Seller listings mode (real output, same card, `includeListings=true`):

```json
{
  "productId": 35427,
  "name": "Lightning Bolt",
  "listingId": 883469487,
  "seller": "Underground Zone",
  "sellerRating": 100,
  "sellerSales": "50000+",
  "verifiedSeller": true,
  "goldSeller": true,
  "directSeller": true,
  "condition": "Damaged",
  "printing": "Normal",
  "language": "English",
  "price": 0.78,
  "shippingPrice": 1.49,
  "totalPrice": 2.27,
  "quantity": 1,
  "currency": "USD",
  "url": "https://www.tcgplayer.com/product/35427"
}
```

### Key output fields

| Field | Type | Description |
|---|---|---|
| `productId` | integer | TCGplayer internal product ID. |
| `name` | string | Card or product name. |
| `set` | string | Set the card belongs to. |
| `number` | string | Collector number within the set. |
| `rarity` | string | Card rarity as listed by TCGplayer. |
| `game` | string | Trading card game the product belongs to. |
| `marketPrice` | float | TCGplayer market price (USD), product mode only. |
| `medianPrice` | float | TCGplayer median price (USD), product mode only. |
| `listingId` | integer | Unique ID of the individual seller listing, listings mode only. |
| `seller` | string | Seller store name, listings mode only. |
| `sellerRating` | integer | Seller rating (0-100), listings mode only. |
| `sellerSales` | string | Seller's lifetime sales bracket, listings mode only. |
| `verifiedSeller` / `goldSeller` / `directSeller` | boolean | TCGplayer seller badges, listings mode only. |
| `condition` | string | Card condition (Mint to Damaged), listings mode only. |
| `printing` | string | Printing/finish (Normal, Foil, Holofoil, etc.), listings mode only. |
| `language` | string | Card language, listings mode only. |
| `price` / `shippingPrice` / `totalPrice` | float | Item price, shipping, and total, listings mode only. |
| `quantity` | integer | Units the seller has in stock at that price, listings mode only. |

### Pricing

Pay-per-result, no subscription:

| Event | Price |
|---|---|
| Result item (product or seller listing, charged once per record) | $0.003 |

Errors are not charged. A 50-item product search costs about $0.15; a seller-listings run opening 10 products at 20 listings each returns up to 200 records for about $0.60.

### What makes this richer than the competition

Most TCGplayer scrapers on the Store return one game and one price per card. This one covers all **8 major TCGs TCGplayer sells** (Pokemon, Magic, Yu-Gi-Oh!, Lorcana, One Piece, Flesh and Blood, Digimon, Star Wars Unlimited) from a single actor, plus an `all` mode that searches every game at once — `memo23`'s own card-price actors are scoped to a single game per listing. `maxItems` also accepts `0` for no limit, so a full want-list or a shop's whole restock sheet can run in one call instead of paging through a fixed cap.

On seller data: `devcake/tcgplayer-data-scraper` (15 users/30d) and `solidcode/tcgplayer-scraper` (5 users/30d) both return seller listings, but neither advertises per-listing seller trust badges (verified, gold, direct) alongside condition, printing and language in the same record — this actor returns all of it in one pass per listing, so a buyer can filter for a trustworthy seller and the right condition without opening a second page.

### Notes & limitations

- Product-mode `marketPrice`/`medianPrice` reflect TCGplayer's own aggregate pricing for the product; they are not recalculated or adjusted by this actor.
- Seller listings mode opens each matched product individually, so it is slower and costs more per record than product mode; keep `maxProducts` and `maxListingsPerProduct` tight for a quick check.
- `sellerSales` is returned as the bracket TCGplayer displays (e.g. "50000+"), not an exact lifetime count.
- This actor reads TCGplayer's own public pages; it does not track price history over time. Run it on a schedule and store the results yourself to build a history.

### FAQ

**Does this need a TCGplayer account or API key?**
No. Both product search and seller listings are read from TCGplayer's public pages.

**Can I search more than one card in a single run?**
Yes, use `queries` with a list of card or product names instead of the single `query` field.

**What's the difference between market price and median price?**
Market price is TCGplayer's rolling average sale price; median price is the midpoint of recent sales. Both come straight from TCGplayer, unmodified.

**Can I filter seller listings by condition or foil/non-foil printing?**
Yes, `condition` and `printing` filter individual listings when `includeListings` is on.

**Does `maxItems: 0` really return everything with no cap?**
Yes, set it to `0` and the run returns every matching product (or every listing, in listings mode) instead of stopping at a fixed count.

### For AI Agents & LLM Apps

This Actor is MCP-compatible and works as a tool call for any LLM agent that needs live trading-card prices.

**Via MCP** (`mcp.apify.com`): add this Actor as a tool in your MCP-compatible client and call it with a `query` and `game`; the agent gets back structured JSON it can reason over directly, no HTML parsing needed.

**Via API** (`run-sync-get-dataset-items`):

```bash
curl "https://api.apify.com/v2/acts/YOUR_ACTOR_ID/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -X POST -H "Content-Type: application/json" \
  -d '{"query": "Charizard ex", "game": "pokemon", "maxItems": 10}'
```

This returns the dataset items directly in the response, ideal for a single synchronous tool call from an agent pipeline.

### Disclaimer

This Actor is an independent tool that reads publicly available pages on tcgplayer.com. It is not affiliated with, endorsed by, or sponsored by TCGplayer, LLC. "TCGplayer" and related marks are trademarks of their respective owners, used here only to describe the data source.

### SEO Keywords

TCGplayer scraper, Pokemon card price API, Magic the Gathering price scraper, TCG seller listings scraper, trading card price tracker, TCGplayer API alternative.

# Actor input Schema

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

Card or product to search for (e.g. "Charizard ex", "Black Lotus"). For several searches in one run, use 'Search queries' below instead.

## `queries` (type: `array`):

Optional list of search queries to run in one go. When set, it takes precedence over the single 'Search query' field.

## `game` (type: `string`):

Which trading card game to search, or all of TCGplayer.

## `sortOption` (type: `string`):

How to order the search results.

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

Maximum number of records to return (products, or individual seller listings when 'Include seller listings' is ON). Set 0 for no limit.

## `includeListings` (type: `boolean`):

When ON, opens each matched product and returns one record per individual seller listing (seller name, rating, verified/gold badges, condition, printing, language, price, shipping, quantity), sorted by total price. Each listing counts as one result.

## `condition` (type: `string`):

Filter seller listings by card condition. Only used when 'Include seller listings' is ON.

## `printing` (type: `string`):

Filter seller listings by printing/finish, e.g. "Normal", "Foil", "Holofoil", "Reverse Holofoil", "1st Edition Holofoil". Leave as "any" for all printings. Only used when 'Include seller listings' is ON.

## `language` (type: `string`):

Filter seller listings by card language. Only used when 'Include seller listings' is ON.

## `maxProducts` (type: `integer`):

How many matched products to open for seller listings. Only used when 'Include seller listings' is ON.

## `maxListingsPerProduct` (type: `integer`):

Cap on seller listings returned per product, cheapest first. Only used when 'Include seller listings' is ON.

## Actor input object example

```json
{
  "query": "Charizard ex",
  "game": "pokemon",
  "sortOption": "best-match",
  "maxItems": 100,
  "includeListings": false,
  "condition": "any",
  "printing": "any",
  "language": "any",
  "maxProducts": 10,
  "maxListingsPerProduct": 50
}
```

# 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 = {
    "query": "Charizard ex",
    "game": "pokemon"
};

// Run the Actor and wait for it to finish
const run = await client.actor("gio21/tcgplayer-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 '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "query": "Charizard ex",
    "game": "pokemon",
}

# Run the Actor and wait for it to finish
run = client.actor("gio21/tcgplayer-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 '{
  "query": "Charizard ex",
  "game": "pokemon"
}' |
apify call gio21/tcgplayer-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,gio21/tcgplayer-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 <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/112dZB7TIjOynmKBv/builds/cAEkkRhnk2ZRogJwQ/openapi.json