# TCGplayer Scraper - Card Prices & Price History (`scrapewise/tcgplayer-scraper`) Actor

Scrape TCGplayer card prices for Pokemon, Magic, Yu-Gi-Oh!, One Piece, Lorcana and more: market, lowest and median price, price by condition and printing, listings count, set, rarity and optional price history with sales. Search or product URLs. Pay per card.

- **URL**: https://apify.com/scrapewise/tcgplayer-scraper.md
- **Developed by:** [Scrapewise Data](https://apify.com/scrapewise) (community)
- **Categories:** E-commerce, Developer tools
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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?

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 Scraper - Card Prices & Price History

**TCGplayer Scraper pulls trading card prices from TCGplayer.com for Pokemon, Magic: The Gathering, Yu-Gi-Oh!, One Piece, Disney Lorcana and every other game on the site: market price, lowest price, median price, listings count, price by condition and printing, and a dated price history with sales.** It is built for card shops, resellers, collectors and anyone who needs a reference price they can trust, at US$ 3 per 1,000 cards.

No login, no API key, no browser. The Actor reads the same public JSON that the TCGplayer website uses to show prices, so runs are fast and cheap. AI agents can call it through the Apify MCP server.

### At a glance

| | This Actor | devcake/tcgplayer-data-scraper (most used in the last 30 days) |
|---|---|---|
| Price per 1,000 products, Free plan | **US$ 3.00** | US$ 3.00 |
| Price per 1,000 products, Gold plan and above | **US$ 2.30** | US$ 2.00 |
| Fee per run start | None | US$ 0.05 per 1,000 run starts |
| Price by condition and printing | Included, same price | Not offered |
| Dated price history (market price, sales, lowest and highest) | US$ 3.00 per 1,000 products, only when asked | Not offered |
| Users in the last 30 days | 1 (published 2026-09-15) | 14 |
| Store rating | No reviews yet | No reviews yet |
| Public run success, last 30 days | No public runs yet; 17 of our 17 test runs succeeded | 98.8% (396 of 401) |
| Last updated | 2026-09-15 | 2026-07-25 |

Competitor figures were read from the public Apify API (`api.apify.com/v2/store?search=tcgplayer`) on **2026-09-15** and change every day; the Store page always shows the live number. Among the ten most relevant TCGplayer Actors that day, prices ran from US$ 3 to US$ 60 per 1,000 products, most of them with an extra fee per run start.

### One real row

Minimal input:

```json
{ "queries": ["charizard"], "game": "pokemon", "maxItems": 30 }
```

A real row from a run of 2026-09-15, trimmed to the price fields (the full row, with the whole condition ladder, is under "Output example" below):

```json
{
  "type": "product",
  "productId": 1174,
  "productName": "Lightning Bolt",
  "game": "Magic: The Gathering",
  "setName": "Alpha Edition",
  "rarity": "Common",
  "currency": "USD",
  "marketPrice": 626.67,
  "lowestPrice": 292.5,
  "medianPrice": 639.99,
  "totalListings": 23,
  "sellersCount": 9,
  "nearMintMarketPrice": 626.67,
  "quantitySold30d": 11,
  "conditionPrices": [
    {"printing": "Normal", "condition": "Near Mint", "marketPrice": 626.67, "quantitySold30d": 6},
    {"printing": "Normal", "condition": "Moderately Played", "marketPrice": 438.24, "quantitySold30d": 4},
    {"printing": "Normal", "condition": "Heavily Played", "marketPrice": 284.25, "quantitySold30d": 1}
  ],
  "url": "https://www.tcgplayer.com/product/1174/magic-alpha-edition-lightning-bolt"
}
```

### What you can do with it

- **Price your store inventory.** Pull the TCGplayer market price for every card you sell every morning and reprice your shop, your Whatnot show or your eBay listings from it.
- **Resell and buy smarter.** Compare the lowest listed price with the market price and the last 30 days of sales for each condition, and spot cards listed well under what they sell for.
- **Arbitrage with eBay and local stores.** Match eBay sold prices or your local buy list against TCGplayer market price by set and card number, and buy only where the spread pays.
- **Track a collection.** Paste the product links of the cards you own and schedule a weekly run: current value, value by condition and the change over the last 3, 6 or 12 months.
- **Watch a new set.** Browse a whole expansion (for example "151" or "Obsidian Flames") filtered by rarity and see which chase cards are rising or falling after release.
- **Feed a spreadsheet, a pricing bot or an AI agent** with clean, flat JSON or CSV.

### Why this one

- **Price by condition and printing.** Near Mint, Lightly Played, Moderately Played, Heavily Played and Damaged, each with its own market price and 30-day sales, plus Normal and Foil market and listed median prices. Most TCGplayer scrapers stop at one market price per card.
- **Real price history.** The same series TCGplayer draws in its price chart: market price, quantity sold, number of sales, lowest and highest sale per period, for each printing, language and condition. One month, 3 months, 6 months or 12 months.
- **Every game.** Pokemon, Pokemon Japan, Magic, Yu-Gi-Oh!, One Piece Card Game, Lorcana, Flesh and Blood, Digimon, Star Wars: Unlimited, Dragon Ball Super, Gundam, Riftbound, Union Arena and the rest of the product lines TCGplayer lists, singles and sealed products.
- **Filters that match the site.** Game, set or expansion, rarity, market price range and the TCGplayer sort orders (best match, best selling, price high to low, price low to high, name).
- **Honest billing.** You pay per unique product delivered. Searches with no results, products that do not exist, invalid links, duplicates and blocked requests come back as rows with an `errorCode` and are never charged.
- **Drop-in input.** It accepts the field names of other TCGplayer scrapers (`queries`, `searchQuery`, `category`, `productLine`, `sortOption`, `pageCount`, `maxResults`, `enrichData`, `rarityFilter`), so you can switch without rewriting your integration.
- **Seller privacy.** It collects product prices only. It does not collect individual seller listings, seller names or buyer data.

### Input example

Search Pokemon for "charizard", sorted by best selling, with price by condition:

```json
{
  "searchQueries": ["charizard"],
  "game": "pokemon",
  "sortBy": "bestSelling",
  "includeDetails": true,
  "maxItems": 50
}
```

Every chase card of one set, most expensive first:

```json
{
  "game": "pokemon",
  "setName": "151",
  "rarity": ["Special Illustration Rare"],
  "sortBy": "priceHighLow"
}
```

Price history for cards you already track:

```json
{
  "mode": "priceHistory",
  "productUrls": [
    "https://www.tcgplayer.com/product/42382/pokemon-base-set-charizard",
    "1174"
  ],
  "historyRange": "annual"
}
```

With an empty input the Actor runs a small example (the "charizard" search in Pokemon, 30 products), so API and MCP calls always return data.

#### Input fields

| Field | What it does |
|---|---|
| `mode` | `search` (default), `products` (details for links or IDs) or `priceHistory` (history rows only). |
| `searchQueries` | Card or product names, one per line. Leave empty and set `game` or `setName` to browse. |
| `game` | Product line: `pokemon`, `magic`, `yugioh`, `one-piece-card-game`, `lorcana-tcg`, `flesh-and-blood-tcg`, `digimon-card-game`, `star-wars-unlimited`, `pokemon-japan`... Short names like `mtg`, `onepiece` or `lorcana` work too. |
| `setName` | Set or expansion, full name or part of it ("Base Set", "151", "Revised Edition"). |
| `rarity` | List of rarities as TCGplayer writes them ("Special Illustration Rare", "Mythic", "Secret Rare"). |
| `minPrice`, `maxPrice` | Market price range in USD. |
| `sortBy` | `bestMatch`, `bestSelling`, `priceHighLow`, `priceLowHigh`, `aToZ`. |
| `maxItems` | Maximum unique products in the run (default 30). |
| `maxItemsPerQuery` | Cap per search term, so the first term does not use the whole `maxItems`. |
| `includeDetails` | Adds median price, sellers count, Normal/Foil prices, buylist market price and price by condition to search results. Always on in `products` mode. No extra charge. |
| `includePriceHistory` | Adds `priceHistory` rows for each product found. Charged per product with history. |
| `historyRange` | `month`, `quarter` (default), `semi-annual` or `annual`. |
| `productUrls` | TCGplayer product links or numeric product IDs. |
| `proxyConfiguration` | Apify datacenter proxy by default. |

### Output example (real run, 15 Sep 2026)

Empty input (the "charizard" example in Pokemon), first 5 rows of the table view:

| productName | setName | cardNumber | rarity | marketPrice | lowestPrice | totalListings |
|---|---|---|---|---|---|---|
| Charizard GX - 9/68 (#60 Charizard Stamped) | Battle Academy | 009/068 | Promo | 14.60 | 7.21 | 158 |
| Charizard - 3/70 (#39 Charizard Stamped) | Battle Academy | 003/070 | Promo | 7.49 | 4.98 | 93 |
| Charizard | Legendary Collection | 003/110 | Holo Rare | 899.99 | 154.96 | 25 |
| Mega Charizard Tin (Mega Charizard X) | Miscellaneous Cards & Products | | | 47.44 | 36.99 | 58 |
| Charizard | Base Set (Shadowless) | 004/102 | Holo Rare | 10000 | 599.99 | 29 |

One product row with details ("lightning bolt" in Magic, sorted by price high to low, `includeDetails` on), shortened:

```json
{
  "type": "product",
  "productId": 1174,
  "productName": "Lightning Bolt",
  "game": "Magic: The Gathering",
  "setName": "Alpha Edition",
  "setCode": "LEA",
  "rarity": "Common",
  "cardType": "Instant",
  "releaseDate": "1993-09-05",
  "currency": "USD",
  "marketPrice": 626.67,
  "lowestPrice": 292.5,
  "medianPrice": 639.99,
  "totalListings": 23,
  "sellersCount": 9,
  "marketPriceNormal": 626.67,
  "listedMedianPriceNormal": 552.49,
  "nearMintMarketPrice": 626.67,
  "quantitySold30d": 11,
  "conditionPrices": [
    {"skuId": 15322, "printing": "Normal", "language": "English", "condition": "Near Mint", "marketPrice": 626.67, "quantitySold30d": 6, "lowSalePrice30d": 640, "highSalePrice30d": 640},
    {"skuId": 332752, "printing": "Normal", "language": "English", "condition": "Moderately Played", "marketPrice": 438.24, "quantitySold30d": 4, "lowSalePrice30d": 551.48, "highSalePrice30d": 551.48},
    {"skuId": 348510, "printing": "Normal", "language": "English", "condition": "Heavily Played", "marketPrice": 284.25, "quantitySold30d": 1, "lowSalePrice30d": 284.25, "highSalePrice30d": 284.25}
  ],
  "imageUrl": "https://tcgplayer-cdn.tcgplayer.com/product/1174_in_1000x1000.jpg",
  "url": "https://www.tcgplayer.com/product/1174/magic-alpha-edition-lightning-bolt",
  "searchQuery": "lightning bolt"
}
```

One price history row (`mode: priceHistory`, "charizard ex" in Pokemon, 3 months), last 3 points of the series:

```json
{
  "type": "priceHistory",
  "productId": 113670,
  "productName": "M Charizard EX",
  "setName": "Generations",
  "cardNumber": "12/83",
  "printing": "Holofoil",
  "language": "English",
  "condition": "Near Mint",
  "historyRange": "quarter",
  "periodStart": "2026-06-19",
  "periodEnd": "2026-09-14",
  "currentMarketPrice": 163.98,
  "startMarketPrice": 157.66,
  "marketPriceChangePercent": 4.01,
  "lowestSalePrice": 144,
  "highestSalePrice": 201.49,
  "totalQuantitySold": 25,
  "history": [
    {"date": "2026-09-08", "marketPrice": 164.88, "quantitySold": 2, "transactionCount": 2, "lowSalePrice": 153.42, "highSalePrice": 154.69},
    {"date": "2026-09-11", "marketPrice": 163.98, "quantitySold": 1, "transactionCount": 1, "lowSalePrice": 144, "highSalePrice": 144},
    {"date": "2026-09-14", "marketPrice": 163.98, "quantitySold": 0, "transactionCount": 0, "lowSalePrice": null, "highSalePrice": null}
  ],
  "url": "https://www.tcgplayer.com/product/113670/pokemon-generations-m-charizard-ex"
}
```

The dataset has four views: **Card prices** (the table above), **Price by condition** (one line per product and condition), **Price history summary** (one line per printing and condition with start, current and change) and **Price history series** (one line per date, ready for a chart).

#### Output fields

| Field | Description |
|---|---|
| `type` | `product`, `priceHistory` or `error`. |
| `productId` | TCGplayer product ID. Use it in `productUrls` for later runs. |
| `productName`, `game`, `gameSlug` | Card or product name and product line. |
| `setName`, `setCode`, `setId` | Set or expansion. |
| `cardNumber`, `rarity`, `cardType`, `energyType` | Card attributes (energy type is the color in Magic). |
| `sealed`, `foilOnly`, `normalOnly`, `releaseDate` | Product flags and set release date. |
| `marketPrice` | TCGplayer market price in USD, based on recent sales. |
| `lowestPrice`, `lowestPriceWithShipping` | Lowest current listing, with and without shipping. |
| `medianPrice` | Median listed price (details). |
| `totalListings`, `sellersCount` | Number of listings and of sellers offering the product. |
| `marketPriceNormal`, `marketPriceFoil`, `listedMedianPriceNormal`, `listedMedianPriceFoil` | Prices per printing (details). |
| `printingPrices` | Market, listed median and buylist market price for each printing (details). |
| `conditionPrices` | Per SKU: printing, language, condition, market price, units sold and lowest and highest sale in the last 30 days (details). |
| `nearMintMarketPrice`, `quantitySold30d` | English Near Mint market price and units sold in 30 days across conditions (details). |
| `skuId`, `printing`, `language`, `condition` | The SKU of a price history row. |
| `periodStart`, `periodEnd`, `historyRange` | Period of the series. |
| `currentMarketPrice`, `startMarketPrice`, `marketPriceChangePercent`, `minMarketPrice`, `maxMarketPrice` | Market price summary for the period. |
| `lowestSalePrice`, `highestSalePrice`, `totalQuantitySold`, `totalTransactionCount`, `averageDailyQuantitySold` | Sales summary for the period. |
| `history` | Series: `date`, `marketPrice`, `quantitySold`, `transactionCount`, `lowSalePrice`, `highSalePrice` and the same with shipping. |
| `imageUrl`, `url` | Product image (1000 px) and TCGplayer product page. |
| `searchQuery`, `input`, `position` | What produced the row and its rank in the search. |
| `scrapedAt`, `sourceUrl` | Collection time (UTC) and the endpoint read. |
| `errorCode`, `error` | `NO_RESULTS`, `SET_NOT_FOUND`, `INVALID_GAME`, `INVALID_PRODUCT`, `PRODUCT_NOT_FOUND`, `NO_PRICE_HISTORY`, `BLOCKED`. Never charged. |

### Pricing

**US$ 3 per 1,000 products, no monthly fee, no charge per run.** Price by condition and printing (`includeDetails`, and the `products` mode) is included at no extra cost.

Price history is a separate event: **US$ 3 per 1,000 products with history** (one charge per product, however many conditions and dates it returns). It is charged only in `priceHistory` mode or when `includePriceHistory` is on.

Store discounts by plan, on the product event: US$ 3.00 per 1,000 on Free, US$ 2.70 on Bronze, US$ 2.50 on Silver, US$ 2.30 on Gold and above.

| Actor | Price per 1,000 products | Price by condition | Price history |
|---|---|---|---|
| **This Actor** | **US$ 3** on Free, **US$ 2.30** on Gold, no start fee | included | US$ 3 per 1,000 products |
| devcake/tcgplayer-data-scraper | US$ 3 + start fee | no | recent sales |
| solidcode/tcgplayer-scraper | US$ 3.55 + start fee | no | recent sales |
| lulzasaur/tcgplayer-scraper | US$ 15 + start fee | no | no |
| parseforge/tcgplayer-scraper (Pokemon only) | about US$ 32 + start fee | no | no |
| apage/tcgplayer-products-listings-sales-scraper | US$ 60 | by listing | optional |

Prices of other Actors as listed in the Apify Store on 15 Sep 2026.

Examples: 1,000 Pokemon cards with market price, lowest price and price by condition cost US$ 3. The same 1,000 cards with a 12-month price history cost US$ 6. A daily repricing run of a 5,000-card store costs US$ 15 a day.

### How to use it

#### In Apify Console

1. Type your card names in **Search terms** or paste links in **Product links or IDs**.
2. Pick a **Game**, and optionally a set, rarity, price range and sort order.
3. Turn on **Include price by printing and condition** or **Include price history** if you need them.
4. Click **Start** and download the results as JSON, CSV or Excel, or open one of the four views.

#### Via API

```bash
curl -X POST "https://api.apify.com/v2/acts/scrapewise~tcgplayer-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"searchQueries": ["black lotus"], "game": "magic", "includeDetails": true, "maxItems": 20}'
```

Python:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("scrapewise/tcgplayer-scraper").call(run_input={
    "game": "one-piece-card-game",
    "searchQueries": ["luffy"],
    "sortBy": "priceHighLow",
    "maxItems": 100,
})
for card in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(card["productName"], card["setName"], card["marketPrice"])
```

Node.js:

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

const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('scrapewise/tcgplayer-scraper').call({
    mode: 'priceHistory',
    productUrls: ['https://www.tcgplayer.com/product/42382/pokemon-base-set-charizard'],
    historyRange: 'annual',
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Scheduling

Create a task with your card list and add a schedule (daily for repricing, weekly for a collection). Each run writes a new dataset, so you can keep the history of your own prices next to the TCGplayer history.

#### Integrations

Send results to Google Sheets, Airtable, Slack, a webhook, n8n, Make or Zapier with Apify integrations. A common setup: daily run, Google Sheets export, and a formula that compares your shop price with `marketPrice` and `nearMintMarketPrice`.

#### AI agents and MCP

The Actor works as a tool in the Apify MCP server, so Claude, ChatGPT, Cursor and other MCP clients can call it: "What is the Near Mint price of Charizard ex 199/165 and how did it move in the last 3 months?". The flat output and the `type` field keep answers short and easy for a model to read.

### Limitations

- Prices are in **USD from the US marketplace**, as TCGplayer shows them. TCGplayer does not publish prices in other currencies.
- **Individual seller listings and the latest sales feed are not collected.** They carry seller data and TCGplayer does not expose them publicly to anonymous clients. You get the aggregate numbers: lowest price, median, listings count, sellers count and sales per period.
- TCGplayer returns **at most 50 products per page and 10,000 results per search**. For very broad searches, split by game, set or rarity.
- `maxItems` counts across all search terms in order. If the first term has thousands of cards it fills the whole run; set `maxItemsPerQuery` to balance terms.
- A product can have **no market price** (no recent sales) or **no price history** in the period. The fields are then `null` and history-only products come back as `NO_PRICE_HISTORY`, not charged.
- The TCGplayer site can change its internal API. If a run returns errors you do not expect, open an issue in the Issues tab and it will be fixed.

This Actor collects only public product data and respects the site's terms. It does not log in, does not bypass any paywall and does not collect personal data.

### FAQ

**Is this an official TCGplayer API?**
No. TCGplayer (owned by eBay) closed new access to its developer API. This Actor reads the public price data the TCGplayer website shows to any visitor.

**What is the difference between market price, lowest price and median price?**
Market price is TCGplayer's estimate based on recent completed sales. Lowest price is the cheapest listing right now. Median price is the middle of the current listings. For pricing a shop, most sellers use market price; for buying, lowest price with shipping.

**Which games are supported?**
Every product line on TCGplayer: Pokemon, Pokemon Japan, Magic: The Gathering, Yu-Gi-Oh!, One Piece Card Game, Disney Lorcana, Flesh and Blood, Digimon, Star Wars: Unlimited, Dragon Ball Super, Gundam, Riftbound, Union Arena, Force of Will, supplies and sealed products. Leave `game` empty to search all of them.

**How do I get the Near Mint price of a card?**
Turn on `includeDetails` (or use `products` mode). Each product gets `nearMintMarketPrice` and the full `conditionPrices` list with every condition and printing.

**How far back does the price history go?**
Up to 12 months with `historyRange: "annual"` (weekly points). `month` gives daily points, `quarter` about every 3 days, `semi-annual` weekly.

**Can I search a whole set?**
Yes. Leave `searchQueries` empty, set `game` and `setName` ("151", "Base Set", "Revised Edition"), and optionally `rarity` and `sortBy`.

**How many products can I get in one run?**
As many as you set in `maxItems`. A run of 320 products took under 90 seconds in our tests. For tens of thousands, split by game or set.

**Why do I see rows with errorCode?**
They explain what happened for a term or link: no results, set not found, invalid link, product not found, no history or a blocked request. They are free and help you fix the input without guessing.

**I use another TCGplayer scraper. Do I need to change my input?**
Usually not. The Actor reads `queries`, `searchQuery`, `category`, `productLine`, `sortOption` ("Best Selling", "Price: High to Low"), `pageCount`, `maxResults`, `limit`, `enrichData`, `includeSalesHistory` and `rarityFilter`.

**Does it work with Google Sheets, n8n, Make or Zapier?**
Yes, through Apify integrations and the Apify nodes for n8n and Make, or by reading the dataset API in CSV or JSON.

**Can I compare TCGplayer with eBay sold prices?**
Yes. Run this Actor and an eBay sold listings scraper on the same card list and join on card name, set and number. `nearMintMarketPrice` and `conditionPrices` make condition matching straightforward.

### Changelog

- **2026-09-15 (page):** added the "At a glance" comparison with the most used TCGplayer Actor, measured on the public Apify API that day (users, rating, run success and last update), the minimal input and a real priced row in the first screen, and the Store discount ladder.
- **0.1 (15 Sep 2026):** first version. Search by term, game, set, rarity and price range with TCGplayer sort orders; product details by link or ID with median price, sellers count, Normal/Foil prices and price by condition; price history mode (month, quarter, semi-annual, annual) per printing, language and condition; four dataset views; error rows without charge; input names of other TCGplayer scrapers accepted.

### Em português

Coleta preços de cartas colecionáveis do TCGplayer (Pokémon, Magic, Yu-Gi-Oh!, One Piece, Lorcana e todos os outros jogos): preço de mercado, menor preço, mediana, quantidade de anúncios, preço por condição e impressão e histórico de preço com vendas. Serve para lojista, revendedor e colecionador.

- Precificar o estoque da loja todo dia pelo preço de mercado do TCGplayer.
- Comparar o preço de mercado e as vendas por condição com o eBay e com a lista de compra da loja local.
- Acompanhar o valor de uma coleção e a variação em 3, 6 ou 12 meses.

Preço: **US$ 3 por 1.000 produtos no plano Free (US$ 2,30 no Gold), sem mensalidade e sem taxa por execução**. Histórico de preço: US$ 3 por 1.000 produtos com histórico, só quando pedido.

Keywords: tcgplayer scraper, tcgplayer api, tcgplayer prices, tcgplayer market price, pokemon card prices, mtg prices, magic the gathering prices, yugioh card prices, one piece card prices, lorcana prices, trading card prices, card price history, tcg price tracker, card market price, near mint price, sealed product prices, card shop pricing, card resale, pricecharting alternative, collection value tracker

# Actor input Schema

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

Search returns one row per product with market and lowest price. Product details opens each product link or ID and adds median price, price per printing (Normal/Foil) and price per condition. Price history returns the dated market price and sales series for each printing and condition, for the products you search or paste. When empty, the Actor uses Search, or Product details if you only paste products.

## `searchQueries` (type: `array`):

Card or product names, one per line (for example "charizard", "black lotus", "blue-eyes white dragon", "booster box"). Each term is searched separately. Leave empty and pick a game or set to browse it. Also accepts 'queries', 'searchQuery', 'query' or 'q' from other TCGplayer scrapers.

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

Limit the search to one game: pokemon, magic, yugioh, one-piece-card-game, lorcana-tcg, flesh-and-blood-tcg, digimon-card-game, star-wars-unlimited, pokemon-japan... Short names like mtg, onepiece or lorcana also work. Leave empty to search every game. 'category' and 'productLine' also work.

## `setName` (type: `string`):

Only products from this set, by name or part of it (for example "Base Set", "151", "Obsidian Flames", "Revised Edition"). Works with or without a search term.

## `rarity` (type: `array`):

Only these rarities, as TCGplayer names them (for example "Special Illustration Rare", "Mythic", "Secret Rare"). 'rarityFilter' also works.

## `minPrice` (type: `number`):

Only products with a TCGplayer market price at or above this.

## `maxPrice` (type: `number`):

Only products with a TCGplayer market price at or below this.

## `sortBy` (type: `string`):

Order of the search results, as on TCGplayer. 'sortOption' values like "Best Selling" or "Price: High to Low" also work.

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

Maximum number of unique products in this run, across all search terms and links. You pay per product delivered. 'maxResults' and 'limit' also work.

## `maxItemsPerQuery` (type: `integer`):

Cap for each term, so one term does not use the whole 'Maximum products'.

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

In Search mode, also open each product and add median price, sellers count, Normal/Foil market and listed median prices, buylist market price and the market price and 30-day sales for each condition (Near Mint to Damaged). Always on in Product details mode. No extra charge.

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

Also add price history rows (type 'priceHistory') for each product found. Charged as a separate event per product with history. Price history mode does this without the product rows.

## `historyRange` (type: `string`):

Period of the price history series.

## `productUrls` (type: `array`):

TCGplayer product pages (https://www.tcgplayer.com/product/42382/pokemon-base-set-charizard) or numeric product IDs from a previous run ('productId'). Used by Product details and Price history modes.

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

Apify datacenter proxy works for TCGplayer. Change only if you see BLOCKED rows.

## Actor input object example

```json
{
  "searchQueries": [
    "charizard"
  ],
  "game": "pokemon",
  "maxItems": 30,
  "includeDetails": false,
  "includePriceHistory": false,
  "historyRange": "quarter",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `results` (type: `string`):

No description

## `resultsCsv` (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 '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "searchQueries": [
        "charizard"
    ],
    "game": "pokemon",
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

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

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapewise/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/Y11finj29LMoXOF3F/builds/8vCpm8uu7hV6aKYC1/openapi.json