# TCGplayer Scraper - Prices & Card Listings (`parsebird/tcgplayer-scraper`) Actor
Scrape TCGplayer card prices, seller listings, and sales history by search query. Extract Pokemon, Magic, Yu-Gi-Oh, and sports card data. Export as JSON, CSV, or Excel.
- **URL**: https://apify.com/parsebird/tcgplayer-scraper.md
- **Developed by:** [ParseBird](https://apify.com/parsebird) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet
## Pricing
from $0.89 / 1,000 results
This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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
### TCGplayer Scraper
Scrape **TCGplayer** card prices, seller listings, and sales data by search query — no official API access needed. **TCGplayer Scraper** searches [TCGplayer.com](https://www.tcgplayer.com), the largest online marketplace for trading card games, and returns clean, structured data for every matching product.
Search any TCGplayer query across Pokemon, Magic: The Gathering, Yu-Gi-Oh!, sports cards, and more — get market price, lowest price, every active seller listing, and optional sales history & price-point enrichment per product.
##### Copy to your AI assistant
Copy this block into ChatGPT, Claude, Cursor, or any LLM to start using this actor.
```
Actor: parsebird/tcgplayer-scraper — Scrape TCGplayer card prices, seller listings, and sales history by search query.
Usage: from apify_client import ApifyClient; client = ApifyClient("YOUR_TOKEN"); run = client.actor("parsebird/tcgplayer-scraper").call(run_input={"queries": ["charizard", "black lotus"], "sortOption": "Price: Low to High", "startPage": 1, "pageCount": 2, "enrichData": False})
Inputs: queries (array of strings, TCGplayer search terms), sortOption (string: "Best Match" | "Best Selling" | "A-Z" | "Price: High to Low" | "Price: Low to High"), startPage (int, default 1), pageCount (int, default 3, max 100, pages per query at 50 products/page), enrichData (bool, default false, fetches sales history and per-printing price points per product)
Output fields: productId, productName, url, imageUrl, productLineName (game/category), setName, setCode, rarityName, number, marketPrice, medianPrice, lowestPrice, lowestPriceWithShipping, totalListings, listings[] (seller, condition, printing, price, shipping, quantity), customAttributes (game-specific card stats), _enrichment (sales & pricePoints, when enrichData is true)
API spec: https://apify.com/parsebird/tcgplayer-scraper/api
Get token: https://console.apify.com/account/integrations
```
### What does TCGplayer Scraper do?
**TCGplayer Scraper** queries TCGplayer's live search index for any card or sealed product name and returns every matching listing as structured JSON — market price, lowest price, per-seller pricing, and card attributes — without you needing to reverse-engineer TCGplayer's API or click through result pages by hand. It works as a **TCGplayer API alternative** for price trackers, arbitrage tools, collection managers, and market-research pipelines.
Key capabilities:
- 🔍 Search by keyword across TCGplayer's entire catalog — no category filter required
- 🃏 Works with **Pokemon**, **Magic: The Gathering**, **Yu-Gi-Oh!**, sports cards (baseball, basketball, football, hockey), **Digimon**, **Dragon Ball Super**, **One Piece**, **Flesh and Blood**, and every other TCGplayer product line
- 💰 Market price, median price, lowest price, and lowest price with shipping per product
- 🏪 Full seller listing breakdown — seller name, rating, sales count, condition, printing, language, price, and shipping per listing
- 📊 Optional enrichment: recent sales history and per-printing (Normal/Foil) price points
- 🔀 Five sort orders: Best Match, Best Selling, A-Z, Price: High to Low, Price: Low to High
- 📄 Multi-page, multi-query pagination in a single run
### What data can you extract from TCGplayer?
| Field | Description |
|-------|-------------|
| `productId` / `productName` | TCGplayer's unique product identifier and full product name |
| `url` / `imageUrl` | Direct product page link and 400x400 product image |
| `productLineName` | Game/category, e.g. "Pokemon", "Magic: The Gathering", "YuGiOh" |
| `setName` / `setCode` | Card set name and abbreviation |
| `rarityName` | Full rarity name, e.g. "Rare Holo" |
| `marketPrice` / `lowestPrice` / `lowestPriceWithShipping` | Current market price and the cheapest active listing, with and without shipping |
| `totalListings` | Number of active seller listings for the product |
| `listings[]` | Every active listing: seller name, rating, sales count, condition, printing, language, price, shipping, quantity |
| `customAttributes` | Game-specific card stats — HP, attacks, and type for Pokemon; power/toughness for Magic; ATK/DEF and level for Yu-Gi-Oh!, etc. |
| `_enrichment.sales` | Recent sale prices and dates (when `enrichData` is enabled) |
| `_enrichment.pricePoints` | Market price and listed median per printing type — Normal, Foil, etc. (when `enrichData` is enabled) |
### How to scrape TCGplayer with TCGplayer Scraper
1. Go to [TCGplayer Scraper](https://apify.com/parsebird/tcgplayer-scraper) on Apify Store
2. Enter one or more search queries, e.g. `charizard`, `black lotus`, `blue eyes white dragon`
3. Pick a **Sort Order** and how many **Pages Per Query** to collect (50 products per page)
4. Turn on **Fetch sales history & price points** if you need recent sale prices and per-printing price points
5. Click **Start** and download results as JSON, CSV, or Excel — or pull them via the API
### Input parameters
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| queries | array | No | `["pokemon cards"]` | TCGplayer search queries |
| sortOption | string | No | "Best Match" | Sort order — see below |
| startPage | integer | No | 1 | Starting page (1-based), applies per query |
| pageCount | integer | No | 3 (max 100) | Pages to scrape per query, 50 products per page |
| enrichData | boolean | No | false | Fetch sales history & price points per product |
**Sort options:** 🎯 Best Match (default relevance) · 🔥 Best Selling (popularity/sales volume) · 🔤 A-Z (alphabetical) · 💰 Price: High to Low · 💸 Price: Low to High
With 3 queries × 2 pages × 50 products, a run returns up to 300 products.
### Output example
```json
{
"productId": 219059,
"productName": "Charizard GX - 9/68 (#60 Charizard Stamped)",
"url": "https://www.tcgplayer.com/product/219059",
"imageUrl": "https://product-images.tcgplayer.com/fit-in/400x400/219059.jpg",
"productLineName": "Pokemon",
"setName": "Battle Academy",
"setCode": "BTA",
"rarityName": "Promo",
"marketPrice": 14.6,
"lowestPrice": 7.21,
"lowestPriceWithShipping": 9.15,
"totalListings": 149,
"listings": [
{
"sellerName": "guubuuhobby",
"sellerRating": 100.0,
"sellerSales": "4397",
"condition": "Near Mint",
"printing": "Holofoil",
"price": 6.27,
"shippingPrice": 0.05,
"totalPrice": 6.32,
"quantity": 1
}
],
"customAttributes": {
"hp": "250",
"stage": "Stage 2",
"energyType": ["Fire"],
"attack1": "[2RR] Flamethrower (140)",
"weakness": "Wx2",
"retreatCost": "3"
},
"_query": "charizard",
"_scrapedAt": "2026-09-13T05:10:49.813Z",
"_enriched": false
}
```
With `enrichData: true`, each product also carries:
```json
{
"_enriched": true,
"_enrichment": {
"pricePoints": {
"normal": { "marketPrice": null, "listedMedian": null },
"foil": { "marketPrice": 14.6, "listedMedian": 14.43 }
},
"sales": {
"totalSales": 5,
"lastSaleDate": "2026-09-12T23:46:36.07Z",
"avgPrice": 12.23,
"priceRange": { "min": 7.21, "max": 17.97 },
"recentSales": [
{ "date": "2026-09-12T23:46:36.07Z", "price": 10.67, "condition": "Lightly Played" }
]
}
}
}
```
### Supported trading card categories
TCGplayer Scraper works across every TCGplayer product line, including:
- ⚡ **Pokemon** — Base Set, Sword & Shield, Scarlet & Violet, and every series in between
- 🧙 **Magic: The Gathering** — Standard, Modern, Commander, Legacy
- 🐉 **Yu-Gi-Oh!** — Main sets, special editions, reprints
- ⚾ **Sports Cards** — Baseball, Basketball, Football, Hockey
- 🎲 **Other TCGs** — Digimon, Dragon Ball Super, One Piece, Flesh and Blood, and more
### Use cases
- 📈 **Price tracking** — Monitor market price and lowest listing price for cards you collect or resell
- 🛒 **Arbitrage research** — Compare seller prices, conditions, and shipping costs to find underpriced listings
- 📊 **Sales history analysis** — Use `enrichData` to see recent sale prices and spot trends before buying or selling
- 🧾 **Collection valuation** — Pull market prices for an entire want-list of cards in one run
- 🤖 **AI agent tooling** — Feed structured TCGplayer data into pricing bots, chat assistants, or inventory pipelines
### How it works
1. Sends each search query to TCGplayer's public search index, requesting up to 50 products per page.
2. Applies the selected sort order (Best Match, Best Selling, A-Z, or price-based) server-side.
3. Paginates through the requested number of pages per query, stopping early once a query runs out of results.
4. Maps each product's market price, listings, and card-specific attributes into a flat, structured record.
5. If `enrichData` is enabled, fetches recent sales history and per-printing price points for every product with bounded concurrency.
6. Pushes records to the dataset as they're scraped.
### How much does it cost to scrape TCGplayer?
TCGplayer Scraper uses two pay-per-event billables:
| Event | Free | Bronze | Silver | Gold |
|-------|------|--------|--------|------|
| `result` (per product scraped) | $1.49 / 1,000 | $1.29 / 1,000 | $1.09 / 1,000 | $0.89 / 1,000 |
| `enrichment` (per product, only when `enrichData` is on) | $0.89 / 1,000 | $0.79 / 1,000 | $0.69 / 1,000 | $0.59 / 1,000 |
A run of 300 products without enrichment costs about $0.45 on the Free plan. Adding `enrichData` for those same 300 products adds roughly $0.27 more. Platform compute is included in the event price — you only pay for results.
### Integrations and API access
TCGplayer Scraper runs on the [Apify platform](https://apify.com), giving you:
- **Scheduling** — Run daily, weekly, or at any custom interval to track price changes
- **API access** — Start runs and fetch results programmatically
- **Webhooks** — Get notified when a run completes
- **Integrations** — Connect to Google Sheets, Slack, Zapier, Make, and [more](https://docs.apify.com/platform/integrations)
- **Export formats** — Download as JSON, CSV, Excel, or XML
#### Python example
```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_API_TOKEN")
run = client.actor("parsebird/tcgplayer-scraper").call(run_input={
"queries": ["charizard", "black lotus"],
"sortOption": "Price: Low to High",
"startPage": 1,
"pageCount": 2,
"enrichData": False,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
print(f"{item['productName']} — ${item.get('marketPrice')} ({item.get('totalListings')} listings)")
```
#### JavaScript example
```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });
const run = await client.actor("parsebird/tcgplayer-scraper").call({
queries: ["charizard", "black lotus"],
sortOption: "Price: Low to High",
startPage: 1,
pageCount: 2,
enrichData: false,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach(item => console.log(`${item.productName} — $${item.marketPrice} (${item.totalListings} listings)`));
```
### Is it legal to scrape TCGplayer?
Web scraping of publicly available data is generally legal, as established by the US Ninth Circuit Court ruling in *hiQ Labs v. LinkedIn* (2022). TCGplayer Scraper collects only publicly visible information from TCGplayer's search results — prices and listings that any visitor can see without logging in.
This actor does not access private account data or bypass payment or authentication systems. Users are responsible for ensuring their use case complies with applicable laws and [TCGplayer's terms of service](https://www.tcgplayer.com/terms).
For more on web scraping legality, see [Apify's guide to web scraping and the law](https://blog.apify.com/is-web-scraping-legal/).
### Related actors
- [Data Deduplicator](https://apify.com/parsebird/dataset-deduplicator) — Remove duplicate records from any Apify dataset
- [Data Cleaner](https://apify.com/parsebird/data-cleaner) — Clean, filter, and transform dataset records
- [HTTP Request Actor](https://apify.com/parsebird/http-request-actor) — Send arbitrary HTTP requests as part of a pipeline
### FAQ
**Why is `rarityName` sometimes missing?**
Not every TCGplayer product line uses rarities the same way — sealed products, storage accessories, and some sports cards don't carry a rarity value, so the field returns `null`.
**Why do some `customAttributes` fields differ between products?**
`customAttributes` mirrors whatever game-specific stats TCGplayer publishes for that product line — Pokemon cards carry HP and attacks, Magic cards carry power/toughness, Yu-Gi-Oh! cards carry ATK/DEF and level. Sealed products typically carry only a description.
**What does `enrichData` actually fetch?**
For each product, it fetches TCGplayer's recent sales feed (condition, price, and date for the most recent trades) and per-printing price points (market price and listed median for Normal, Foil, and other printings). It's an extra request per product, billed at the `enrichment` rate.
**Can I search for a specific set or card number?**
Yes — TCGplayer's search understands set names and card numbers as part of the query text, e.g. `charizard base set` or `charizard 4/102`.
**Can I schedule recurring runs?**
Yes. Use [Apify's scheduling feature](https://docs.apify.com/platform/schedules) to run this actor daily, weekly, or at any custom interval, and combine it with webhooks to track price movements automatically.
**Do I need a proxy for this actor?**
No. TCGplayer's search and pricing endpoints are called directly with no proxy required.
# Actor input Schema
## `queries` (type: `array`):
TCGplayer card search queries, e.g. charizard, black lotus, blue eyes white dragon. Each query searches store listings across every TCGplayer category (Pokemon, Magic, Yu-Gi-Oh!, sports cards, and more).
## `sortOption` (type: `string`):
Order search results are returned in.
## `startPage` (type: `integer`):
First page to scrape (1-based). Applies to every query. Each page returns up to 50 products.
## `pageCount` (type: `integer`):
Number of pages to scrape per query, starting from Start Page. Each page holds up to 50 products, so 2 pages ≈ 100 products per query.
## `enrichData` (type: `boolean`):
For every product found, fetch its recent sales history and per-printing price points (Normal/Foil) with an extra request. Slower and billed at the enrichment rate — see Pricing in the README.
## Actor input object example
```json
{
"queries": [
"pokemon cards"
],
"sortOption": "Best Match",
"startPage": 1,
"pageCount": 2,
"enrichData": false
}
```
# 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 = {
"queries": [
"pokemon cards"
],
"sortOption": "Best Match",
"startPage": 1,
"pageCount": 2
};
// Run the Actor and wait for it to finish
const run = await client.actor("parsebird/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 '' with your token.
client = ApifyClient("")
# Prepare the Actor input
run_input = {
"queries": ["pokemon cards"],
"sortOption": "Best Match",
"startPage": 1,
"pageCount": 2,
}
# Run the Actor and wait for it to finish
run = client.actor("parsebird/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 '{
"queries": [
"pokemon cards"
],
"sortOption": "Best Match",
"startPage": 1,
"pageCount": 2
}' |
apify call parsebird/tcgplayer-scraper --silent --output-dataset
```
## MCP server setup
```json
{
"mcpServers": {
"apify": {
"type": "http",
"url": "https://mcp.apify.com/?tools=fetch-actor-details,parsebird/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 ` 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/nYemedOl43SmV8Gy3/builds/vstilSCfZRgPwoUDy/openapi.json