# TCGplayer Price Scraper (`xtracto/tcgplayer-price-scraper`) Actor

Search trading cards by keyword and get market, lowest, and per-printing prices for each matching product.

- **URL**: https://apify.com/xtracto/tcgplayer-price-scraper.md
- **Developed by:** [Farhan Febrian Nauval](https://apify.com/xtracto) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $20.00 / 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/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

## TCGplayer Price Scraper

Search trading cards by keyword and get the current market price, lowest available price, and per-printing price points for every matching product.

### Why use this actor

- **Real market prices** — each card comes through with its market price, lowest listed price, and median, straight from the live marketplace.
- **Per-printing detail** — optionally enrich every card with market, median, and buylist prices broken out by printing (Normal, Foil, Holofoil, and more).
- **Full card identity** — product name, set, set code, collector number, rarity, and product line so you can match cards exactly.
- **Built-in product links and images** — every record includes a ready-to-open product URL and an image URL.
- **No account, no API key** — works straight from public trading-card search and market prices.
- **Stable JSON output** — same field names every run, ready for spreadsheets, databases, or pipelines.

### How it works

1. You provide one or more card search terms (for example `charizard` or `black lotus`).
2. The actor searches the trading-card marketplace for each term and collects every matching product.
3. Each product is saved as a `CARD` record with its name, set, number, rarity, and prices.
4. When per-printing price points are enabled, each card is enriched with market, median, and buylist prices for every printing.
5. Everything lands in your dataset, exportable as JSON, CSV, or Excel.

You don't need to manage any browsers or scrapers.

### Input

```json
{
    "queries": [
        "charizard",
        "black lotus"
    ],
    "maxResultsPerQuery": 50,
    "enrichPricePoints": true,
    "maxConcurrency": 4,
    "maxRequestRetries": 5,
    "proxyConfiguration": { "useApifyProxy": true }
}
````

This run looks up two card terms (`charizard` and `black lotus`), returns up to 50 matching products for each, and enriches every card with its per-printing price points.

| Field | Type | Description |
| --- | --- | --- |
| `queries` | array | **Required.** Card search terms to look up market prices for (one per entry). |
| `maxResultsPerQuery` | integer | How many matching card products to return per term. Raise it for more cards per term, lower it for a quick sample. Default `24`. |
| `enrichPricePoints` | boolean | Add per-printing market / median / buylist prices to each card. Turn it off for a faster run that skips the extra per-card lookup. Default `true`. |
| `maxConcurrency` | integer | Number of parallel requests. Default `4`. |
| `maxRequestRetries` | integer | Retries per request before giving up. Default `5`. |
| `proxyConfiguration` | object | Apify Proxy or a custom proxy list. The card-market feeds are open, so the default datacenter proxy is fine; residential is not required. |

All prices are in **US dollars (USD)** — this is the US trading-card marketplace, so every price field is quoted in USD regardless of where the run happens.

### Output

Each matching card is one record (`recordType: "CARD"`):

```json
{
    "recordType": "CARD",
    "_input": "charizard",
    "productId": 219059,
    "name": "Charizard GX - 9/68 (#60 Charizard Stamped)",
    "set": "Battle Academy",
    "setCode": "BTA",
    "number": "009/068",
    "rarity": "Promo",
    "productLine": "Pokemon",
    "marketPrice": 11.87,
    "lowestPrice": 7.99,
    "medianPrice": null,
    "lowestPriceWithShipping": 8.49,
    "totalListings": 81,
    "foilOnly": true,
    "sealed": false,
    "releaseDate": "2020-07-31T00:00:00Z",
    "currency": "USD",
    "url": "https://www.tcgplayer.com/product/219059",
    "image": "https://product-images.tcgplayer.com/fit-in/437x437/219059.jpg",
    "scrapedAt": "2026-06-10T11:00:44Z",
    "pricePoints": [
        { "printing": "Normal", "marketPrice": null, "listedMedianPrice": null, "buylistMarketPrice": null },
        { "printing": "Foil", "marketPrice": 11.87, "listedMedianPrice": 14.1, "buylistMarketPrice": null }
    ]
}
```

| Field | Type | Description |
| --- | --- | --- |
| `recordType` | string | Always `"CARD"`. |
| `_input` | string | The search term that produced this record. |
| `productId` | integer | Marketplace product identifier (also the join key and image/URL key). |
| `name` | string | Card / product name. |
| `set` | string | Set name. |
| `setCode` | string | Short set code. |
| `number` | string | Collector number when the product is a single card. |
| `rarity` | string | Card rarity when available. |
| `productLine` | string | Game / product line (e.g. `Pokemon`, `Magic`). |
| `marketPrice` | number | Current market price. |
| `lowestPrice` | number | Lowest listed price. |
| `medianPrice` | number | Median listed price when available. |
| `lowestPriceWithShipping` | number | Lowest price including shipping. |
| `totalListings` | integer | Number of active listings for the product. |
| `foilOnly` | boolean | Whether the product exists only as a foil printing. |
| `sealed` | boolean | Whether the product is a sealed item. |
| `releaseDate` | string | Release date when available. |
| `currency` | string | ISO currency of the prices (`USD`). |
| `url` | string | Product page URL. |
| `image` | string | Product image URL. |
| `scrapedAt` | string | ISO 8601 timestamp of collection. |
| `pricePoints` | array | Per-printing `printing` / `marketPrice` / `listedMedianPrice` / `buylistMarketPrice` (present when enrichment is enabled). |

On a search term that returns nothing, the actor emits a single record with `error: "NO_RESULTS"` instead of skipping silently. If a search can't be completed after all retries, it emits `error: "BLOCKED_AFTER_RETRIES"`.

### Other Card Scrapers

| Actor | Description |
| --- | --- |
| [TCGplayer Price Scraper](https://apify.com/tcgplayer-price-scraper) | Trading-card search with market, lowest, and per-printing prices per keyword. |

# Actor input Schema

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

Trading-card search terms to look up market prices for (one per array entry).

## `maxResultsPerQuery` (type: `integer`):

How many matching card products to return per search term.

## `enrichPricePoints` (type: `boolean`):

When enabled, each card is enriched with per-printing market, median, and buylist prices.

## `maxConcurrency` (type: `integer`):

Maximum number of parallel requests.

## `maxRequestRetries` (type: `integer`):

How many times a request will be retried before giving up.

## `proxyConfiguration` (type: `object`):

Apify Proxy or your own proxy list. The card-market feeds are open, so the default datacenter proxy is fine; residential is not required.

## Actor input object example

```json
{
  "queries": [
    "charizard"
  ],
  "maxResultsPerQuery": 24,
  "enrichPricePoints": true,
  "maxConcurrency": 4,
  "maxRequestRetries": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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 = {
    "queries": [
        "charizard"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("xtracto/tcgplayer-price-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 = {
    "queries": ["charizard"],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("xtracto/tcgplayer-price-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 '{
  "queries": [
    "charizard"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call xtracto/tcgplayer-price-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=xtracto/tcgplayer-price-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TCGplayer Price Scraper",
        "description": "Search trading cards by keyword and get market, lowest, and per-printing prices for each matching product.",
        "version": "1.0",
        "x-build-id": "HXO6b5Qc1rowjGx8R"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/xtracto~tcgplayer-price-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-xtracto-tcgplayer-price-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/xtracto~tcgplayer-price-scraper/runs": {
            "post": {
                "operationId": "runs-sync-xtracto-tcgplayer-price-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/xtracto~tcgplayer-price-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-xtracto-tcgplayer-price-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": [
                    "queries"
                ],
                "properties": {
                    "queries": {
                        "title": "Card search terms",
                        "type": "array",
                        "description": "Trading-card search terms to look up market prices for (one per array entry).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResultsPerQuery": {
                        "title": "Max results per query",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "How many matching card products to return per search term.",
                        "default": 24
                    },
                    "enrichPricePoints": {
                        "title": "Include per-printing price points",
                        "type": "boolean",
                        "description": "When enabled, each card is enriched with per-printing market, median, and buylist prices.",
                        "default": true
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Maximum number of parallel requests.",
                        "default": 4
                    },
                    "maxRequestRetries": {
                        "title": "Max retries",
                        "minimum": 1,
                        "maximum": 15,
                        "type": "integer",
                        "description": "How many times a request will be retried before giving up.",
                        "default": 5
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify Proxy or your own proxy list. The card-market feeds are open, so the default datacenter proxy is fine; residential is not required."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
