# LigaPokemon Card Price Scraper - Seller Offers, No Item Cap (`gio21/ligapokemon-scraper`) Actor

Get Pokemon card prices from LigaPokemon (Brazil) in BRL: aggregated min/avg/max per card or per-seller offers with condition, language and quantity. No item cap, no login. Pay $0.005 per run plus $0.006 per result.

- **URL**: https://apify.com/gio21/ligapokemon-scraper.md
- **Developed by:** [Gio](https://apify.com/gio21) (community)
- **Categories:** E-commerce
- **Features:** Limited permissions
- **Stats:** 69 total users, 7 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $0.005 / actor start

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

## LigaPokemon Card Price Scraper - Seller Offers, No Item Cap

### Why use this scraper

If you buy, sell or trade Pokemon cards in Brazil, LigaPokemon is the
marketplace that sets the real price: it is the largest Pokemon TCG trading
platform in the country, with thousands of sellers listing the same card at
different prices, conditions and languages. Checking prices by hand means
opening dozens of seller pages one by one, in Portuguese, and keeping a
spreadsheet up to date by copy-pasting. This scraper turns that into a single
search: give it a card name and get either the aggregated market price (min,
average, max in BRL) or every individual seller offer with condition,
language, finish and quantity, ready to paste into a spreadsheet, feed a
pricing bot or compare against TCGplayer for cross-border arbitrage.

### Overview

The actor searches LigaPokemon for a card or product name and returns
structured pricing data in Brazilian reais (BRL). It has two output modes.
In the default aggregated mode, you get one record per matched card version
with the minimum, average and maximum price currently offered across all
sellers on the marketplace, in a few seconds per card. In seller-offers mode,
the actor opens each matched card's page and returns one record per
individual seller listing: seller name and location, card condition,
language, finish/variant, exact price, quantity available, and whether the
listing is a fixed price or an active auction. A typical run for one card
name in aggregated mode finishes in under 30 seconds; seller-offers mode
takes longer because it opens each matched version's page, roughly
1 to 3 seconds per version opened. Pricing is pay-per-result: a small actor
start fee plus a fee per card or per offer returned, with no limit on how
many languages or product types you request.

### Supported inputs

- **Card or product name (`query`)** - free text search exactly like typing
  into LigaPokemon's own search box, e.g. "Charizard ex", "Pikachu VMAX",
  or a full product name like a booster box or deck. This is the only
  required field.
- **Language filter (`language`)** - restrict results to a single printed
  language (English, Portuguese, Japanese, Spanish, Italian, French, German,
  Korean or Chinese), read directly from the card listing title. Useful when
  comparing against a specific TCGplayer language edition.
- **Seller offers toggle (`includeOffers`)** - flips the actor from
  aggregated mode to per-seller-offer mode.
- **Condition filter (`condition`)** - in offer mode, keep only listings in a
  given condition: Mint, Near Mint, Slightly Played, Moderately Played,
  Heavily Played or Damaged.
- **Max card versions to open (`maxProducts`)** - in offer mode, how many
  matched card printings/editions to open for offers (default 10, up to 50).
- **Max items (`maxItems`)** - hard cap on returned records, cards or offers
  depending on mode. Set to `0` for no limit at all.

### Use cases

- **Collectors pricing a collection.** Run every card in a binder through
  the actor in aggregated mode to get a current market value in BRL for
  insurance, resale or trade negotiation, without opening 50 browser tabs.
- **Cross-market arbitrage traders.** Compare LigaPokemon's BRL price
  against TCGplayer's USD price for the same card and language to spot cards
  that are cheaper to import or export between the two markets.
- **Marketplace sellers setting competitive prices.** Pull every active
  seller offer for a card before listing your own, to see the real spread
  (not just the headline "from" price) and undercut or match it deliberately.
- **Price-tracking dashboards and bots.** Schedule the actor daily for a
  watchlist of cards and feed the aggregated min/avg/max into a spreadsheet
  or alerting system to catch price spikes around new set releases.
- **TCG content creators and YouTubers.** Source accurate, dated price data
  for "most valuable cards this month" videos and articles instead of
  guessing from memory or a single listing.

### How it works

The actor talks to LigaPokemon's own search and product pages the same way a
browser does: it submits the card name to the search endpoint, reads the
matched product list, and for aggregated mode reads the price range already
shown on each product's page. For seller-offers mode, it additionally opens
each matched product page and reads the full offer table, including
auction-style listings, to capture per-seller price, condition, language,
finish and quantity. This means prices update as soon as sellers change
them on the site, there is no cached or delayed snapshot layer in between.

### Input configuration

**Aggregated price for a single card:**

```json
{ "query": "Charizard ex", "maxItems": 100 }
```

**Seller offers filtered by condition and language:**

```json
{
  "query": "Blaziken ex",
  "includeOffers": true,
  "condition": "NM",
  "language": "portuguese",
  "maxProducts": 20
}
```

**English-only aggregated prices for arbitrage against TCGplayer USD:**

```json
{ "query": "Pikachu VMAX", "language": "english", "maxItems": 50 }
```

### Output sample

Real items from a production run (aggregated mode, query "Charizard ex"):

```json
{
  "name": "(ING) Box Coleção Especial - Charizard Ex",
  "language": "english",
  "priceMin": 389.90,
  "priceAvg": 391.90,
  "priceMax": 399.90,
  "currency": "BRL",
  "source": "ligapokemon",
  "url": "https://www.ligapokemon.com.br/?view=prod/view&pcode=133241&prod=Charizard+Ex+Special+Collection",
  "scrapedAt": "2026-09-26T20:28:49.770Z"
}
```

```json
{
  "name": "(PT-BR) Baralho Pré Construído - Baralho Batalha de Liga - Charizard ex",
  "language": "portuguese",
  "priceMin": 74.75,
  "priceAvg": 109.50,
  "priceMax": 199.00,
  "currency": "BRL",
  "source": "ligapokemon",
  "url": "https://www.ligapokemon.com.br/?view=prod/view&pcode=132673&prod=%28PT-BR%29+League+Battle+Deck+-+Charizard+ex",
  "scrapedAt": "2026-09-26T20:28:49.770Z"
}
```

### Key output fields

| Field | Type | Description |
|-------|------|-------------|
| `name` | string | Full product/card name as listed, including set or box name when relevant |
| `language` | string | Printed language detected from the listing title |
| `priceMin` | number | Lowest current seller price for this card (aggregated mode) |
| `priceAvg` | number | Average current seller price |
| `priceMax` | number | Highest current seller price |
| `seller` | string | Seller name (seller-offers mode only) |
| `condition` | string | Card condition label (seller-offers mode only) |
| `finish` | string | Variant/finish such as Normal, Foil, Reverse Foil (seller-offers mode only) |
| `price` | number | Exact single-offer price (seller-offers mode only) |
| `quantity` | number | Units available at that price (seller-offers mode only) |
| `currency` | string | Always `BRL` |
| `url` | string | Direct LigaPokemon product URL |

### Pricing

Pay per result, billed in USD regardless of the BRL prices returned:

| Event | Price |
|-------|-------|
| Actor start | $0.005 (once per run) |
| Result item (card or offer) | $0.006 |

Errors are never charged, only successfully returned cards or offers.

### What makes this richer than the competition

Two other Store listings cover LigaPokemon directly. `getascraper/ligapokemon-scraper`
("LigaPokemon Scraper: Batch Search for Pokémon TCG Prices in BRL", 1
user/30 days) charges $0.005 per result item and focuses on aggregated batch
search. `dami_studio/ligapokemon-card-prices-scraper` ("Liga Pokemon Card
Prices Scraper", 1 user/30 days) charges $0.001 actor start plus $0.0015 per
card returned, undercutting on price for the basic aggregated lookup. Our
actor is the only one of the three offering a second mode with per-seller
offer detail (seller name, condition, language, finish, exact price and
quantity, including active auctions), which the arbitrage and reselling use
cases above need and a plain aggregated min/avg/max does not provide.

### Notes & limitations

- Aggregated prices reflect LigaPokemon's own listed range at scrape time,
  calculated from that card's live seller offers; they are not an
  independent appraisal.
- Seller-offers mode opens each matched card version individually, so it is
  slower and costs more per item than aggregated mode. Use `maxProducts` to
  control how many versions get opened.
- The actor only covers LigaPokemon. For direct comparison against
  TCGplayer USD pricing for the same card, see our separate
  `card-arbitrage` actor.
- Card names in Portuguese product listings (decks, boxes, tins) may not
  have a direct English equivalent; search by the exact LigaPokemon listing
  name shown on the site for best matches.
- This actor is not affiliated with or endorsed by LigaPokemon. It extracts
  publicly available marketplace data for research and pricing purposes.

### FAQ

**What do `priceMin`, `priceAvg` and `priceMax` mean?**
They are the cheapest, average and most expensive current seller offers on
LigaPokemon's marketplace for that exact card listing, at the moment the
actor ran.

**Can I search for more than one card per run?**
Yes, run the actor once per card name for best accuracy. Each run is fast
(seconds for aggregated mode), so looping over a list of card names from
your own code or via the API is the normal way to price a full collection.

**Does `maxItems: 0` really mean unlimited?**
Yes. Set `maxItems` to `0` to return every matched card or offer with no
cap, useful when a search term is specific enough not to need a limit.

**Why are some seller offers missing a `quantity` or `finish` value?**
Not every seller fills in every field on LigaPokemon; the actor returns
whatever the seller's own listing provides and never invents a value.

**Is this affiliated with LigaPokemon?**
No. This is an independent tool for extracting publicly available data.
Please respect LigaPokemon's terms of service when using the data.

### For AI Agents & LLM Apps

This actor is available over the Apify MCP server (`mcp.apify.com`), so any
MCP-compatible agent (Claude, Cursor, other LLM clients) can call it as a
tool directly, with the card name as the only required input. It can also be
called synchronously from any backend or agent framework via the
`run-sync-get-dataset-items` endpoint, which returns the dataset items in a
single HTTP response instead of requiring a separate poll-and-fetch step:

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

### Disclaimer

LigaPokemon is a trademark of its respective owner. This actor is an
independent tool, not affiliated with, endorsed by or sponsored by
LigaPokemon. It extracts publicly available pricing data for personal and
research use; respect LigaPokemon's terms of service.

### SEO Keywords

LigaPokemon scraper, Pokemon card price scraper Brazil, Pokemon TCG price
API, LigaPokemon API, Pokemon card arbitrage BRL.

# Actor input Schema

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

Pokemon card or product to search for (e.g. "Charizard ex").

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

Filter cards by printed language (read from the card title, e.g. (ING), (PT-BR), (JAP)). For fair arbitrage against TCGplayer (US), use English.

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

Maximum number of items to return (cards, or individual offers when 'Include seller offers' is ON). Set 0 for no limit.

## `includeOffers` (type: `boolean`):

When ON, opens each matched card's page and returns one record per individual seller listing (seller name, condition, language, exact price, quantity), instead of one aggregated record per card. Auction listings are included with their current bid. Each offer counts as one result.

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

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

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

How many matched card versions (editions) to open for seller offers. Only used when 'Include seller offers' is ON.

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

Proxy used for requests. A Brazilian residential proxy is required (LigaPokemon blocks foreign IPs via Cloudflare) and is set by default.

## Actor input object example

```json
{
  "query": "Charizard ex",
  "language": "any",
  "maxItems": 100,
  "includeOffers": false,
  "condition": "any",
  "maxProducts": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "BR"
  }
}
```

# 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",
    "language": "any"
};

// Run the Actor and wait for it to finish
const run = await client.actor("gio21/ligapokemon-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",
    "language": "any",
}

# Run the Actor and wait for it to finish
run = client.actor("gio21/ligapokemon-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",
  "language": "any"
}' |
apify call gio21/ligapokemon-scraper --silent --output-dataset

```

## MCP server setup

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