PokéWallet API: Developer-First Pokémon TCG Platform Launches

📅 UPDATE — November 3, 2026: this post announced our launch in January 2026, when every new user got Early Access limits (1,000 requests/hour, 10,000/day). The API left beta in February: new users now start on the Free plan (100 requests/hour, 1,000/day), and paid plans add higher limits and analytics endpoints: Coffee (any amount on Ko-fi), Pro (€20/month), Ultra (€29/month, all 12 games) and Business. Early Access users keep their limits. We've updated the facts, code samples and comparisons below to match the API as it is today. See pricing.

Quick Answer: The PokéWallet API is a free Pokémon TCG REST API providing access to 50,000+ cards with TCGPlayer and CardMarket prices refreshed daily. Start free with 1,000 requests per day and upgrade anytime. Perfect for building collection trackers, price monitoring tools, and market analysis apps. Features comprehensive card metadata, set information, and multi-marketplace pricing aggregation through clean REST endpoints. No credit card required.

Building a Pokémon TCG application has often meant juggling tight free quotas, card data without prices, and prices scattered across marketplaces. Developers have worked around these gaps with scrapers, caches, and spreadsheets.

The PokéWallet API is our answer.

We launched a developer-first platform built to remove barriers for everyone, from students coding their first collection tracker to professional developers building marketplace integrations. Whether you're building a portfolio analyzer, a deck cost calculator, or an investment tracker, PokéWallet gives you card data and market prices in one place.


Table of Contents

Generous Free Tier and Rate Limits

📌 TL;DR: Every new user gets a Free plan with 100 requests an hour and 1,000 a day, with TCGPlayer and CardMarket prices on every card. At launch, Early Access users got 10,000 requests a day, and they keep those limits. When you need more, Coffee, Pro and Ultra raise the limits without changing your code.

Rate limits shape what you can build. Too low, and you end up choosing between:

  • Building "hobbyist-only" features that barely function
  • Implementing complex caching that adds weeks to development
  • Paying for a big plan before you know whether anyone will use your app

PokéWallet's plans are designed so you can start for free and grow step by step.

Rate Limit Comparison

ProviderDaily LimitHourly LimitPriceNotes
PokéWallet Free1,000 requests100 requests€0/monthAll new users, card prices included
PokéWallet Coffee10,000+ requests1,000+ requestsAny amount on Ko-fi+25% per coffee, 1 month
PokéWallet Pro50,000 requests5,000 requests€20/monthPrice history and set analytics
PokéWallet Ultra70,000 requests7,000 requests€29/monthAll 12 games
TCGdexNo published limitsNo published limits$0/monthNo key; asks users to cache
PokémonTCG.io20,000 with a key; 1,000 without30 per minute without a key$0/monthDeprecated: no new keys, shuts down March 1, 2027

Limits for TCGdex and PokémonTCG.io come from their own documentation, checked in October 2026.

Real-world usage example:

A collection tracker with 200 users, each with 50 cards, checking their portfolio values 3 times a day:

  • Without caching: 200 users × 3 checks × 50 cards = 30,000 requests/day, which fits in Pro (50,000/day)
  • With caching: prices are refreshed once a day, so you only need to fetch each card once a day: 200 × 50 = 10,000 requests/day, which fits in Coffee
  • Smarter still: many users own the same cards, so caching by card ID brings the number down further

For most developers starting out, 1,000 daily requests on the Free plan is enough to build, test, and launch an MVP; caching prices for the day stretches it further.

REST API Architecture

📌 TL;DR: PokéWallet uses clean REST architecture with intuitive endpoints like /cards/:id and /search. Authentication via a simple API key header, responses in predictable JSON, official SDKs for TypeScript and Python, and documentation with examples in cURL, JavaScript, Python and Go.

We chose REST for maximum accessibility and simplicity. There's no GraphQL schema to learn: every endpoint is a plain HTTP call.

Why REST?

Developer familiarity: Most TCG app builders already know REST patterns, so there's no learning curve.

Simple authentication: A single API key in a header, with no complex token management:

curl -H "X-API-Key: pk_live_your_key_here" \
     "https://api.pokewallet.io/search?q=charizard"

Predictable responses: Every endpoint returns consistent JSON structures.

Easy debugging: Standard HTTP status codes and clear error messages.

Core Endpoints

Our API documentation has the complete reference, but here are the key endpoints:

Search Cards

// Search for cards by name, set or card number
GET /search?q=charizard&limit=20

// Example response (one result shown, shortened)
{
  "query": "charizard",
  "results": [
    {
      "id": "pk_f45432e30a85f19b...",
      "card_info": {
        "name": "Charizard",
        "set_name": "Base Set",
        "set_code": "BS",
        "card_number": "004/102",
        "rarity": "Holo Rare"
      },
      "tcgplayer": {
        "prices": [
          { "sub_type_name": "Holofoil", "market_price": 987.13, "low_price": 475, "updated_at": "2026-11-03T09:50:01" }
        ]
      },
      "cardmarket": {
        "prices": [
          { "variant_type": "normal", "avg": 458.1, "trend": 411.22, "updated_at": "2026-11-03T09:38:33" }
        ]
      }
    }
  ],
  "pagination": { "page": 1, "limit": 20, "total": 549, "total_pages": 28 }
}

Get Card by ID

# Fetch detailed card information
import requests

headers = {"X-API-Key": "pk_live_your_key_here"}
response = requests.get(
    "https://api.pokewallet.io/cards/pk_f45432e30a85f19b...",
    headers=headers
)

card = response.json()
tcg = card.get("tcgplayer")  # null when the card isn't listed on TCGPlayer
if tcg and tcg["prices"]:
    print(f"{card['card_info']['name']} - ${tcg['prices'][0]['market_price']}")

Browse Sets

// Get all available sets
package main

import (
    "fmt"
    "io"
    "net/http"
)

func main() {
    req, _ := http.NewRequest("GET", "https://api.pokewallet.io/sets", nil)
    req.Header.Add("X-API-Key", "pk_live_your_key_here")

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))
}

Get Set Details

// Fetch a set with its cards (paginated)
const res = await fetch('https://api.pokewallet.io/sets/BS', {
  headers: { 'X-API-Key': 'pk_live_your_key_here' }
});
const data = await res.json();
console.log(`${data.set.name} has ${data.set.total_cards} cards`); // "Base Set has 110 cards"

Response Structure

List endpoints follow consistent patterns. /search, for example, returns the query, the results, and pagination:

Success responses (200 OK):

{
  "query": "charizard",
  "results": [ /* cards */ ],
  "pagination": { "page": 1, "limit": 20, "total": 549, "total_pages": 28 }
}

Error responses (4xx/5xx) return JSON with an error and a message. For example, a request without a key:

{
  "error": "Missing API key",
  "message": "Please provide an API key in the X-API-Key header"
}

Every response includes rate limit headers so you always know your quota status (values for the Free plan):

X-RateLimit-Limit-Hour: 100
X-RateLimit-Remaining-Hour: 95
X-RateLimit-Limit-Day: 1000
X-RateLimit-Remaining-Day: 823

Multi-Marketplace Pricing

📌 TL;DR: PokéWallet brings together prices from TCGPlayer and CardMarket, the largest marketplaces in North America and Europe. These are secondary market prices, not MSRP, refreshed daily and returned by the same endpoints as card data.

A card database is only as useful as its prices are current. As we explored in our evolution of price tracking article, the TCG market moves fast, especially around new releases like Phantasmal Flames.

Multi-Marketplace Coverage

TCGPlayer (North America, USD), for each printing:

  • Market price
  • Low, mid and high price
  • Direct low price (TCGPlayer Direct)

CardMarket (Europe, EUR), for each variant:

  • Average sell price and lowest price
  • Trend price
  • 1-, 7- and 30-day averages

Both are refreshed daily, and each price row carries an updated_at timestamp. When a card isn't listed on one marketplace, that field is null.

Example pricing data structure (Base Set Charizard, November 3, 2026, shortened):

{
  "id": "pk_f45432e30a85f19b...",
  "card_info": { "name": "Charizard", "set_name": "Base Set", "card_number": "004/102" },
  "tcgplayer": {
    "prices": [
      {
        "sub_type_name": "Holofoil",
        "market_price": 987.13,
        "low_price": 475,
        "mid_price": 605,
        "high_price": 3499.1,
        "updated_at": "2026-11-03T09:50:01"
      }
    ],
    "url": "https://www.tcgplayer.com/product/42382"
  },
  "cardmarket": {
    "prices": [
      {
        "variant_type": "normal",
        "avg": 458.1,
        "low": 99,
        "trend": 411.22,
        "avg7": 390.77,
        "avg30": 457.47,
        "updated_at": "2026-11-03T09:38:33"
      }
    ]
  }
}

Why This Matters

For collection trackers: Calculate portfolio values in USD and EUR.

For price monitoring: Alert users when a card crosses a target price on either marketplace.

For market analysis: Compare price differences between North American and European markets.

For investment tools: Track card performance across two data sources, and on Pro use the price history endpoint for snapshots from 7 to 120 days ago.

As seen with recent sets like Mega Dream ex, two marketplaces give a fuller picture of a card's value: a single marketplace can show higher or lower prices because of regional supply and demand.

Developer-Ready from Day One

📌 TL;DR: PokéWallet API comes with complete documentation, code examples in cURL, JavaScript, Python and Go, official SDKs for TypeScript and Python, and an API that runs on Cloudflare's edge network. Built for usability, not just data access.

We built PokéWallet with one principle: if developers can't use it easily, it doesn't matter how much data we have.

Comprehensive Documentation

The API docs aren't an afterthought; they're a core product feature:

  • ✅ Getting started guide: your first API call in a few minutes
  • ✅ Endpoint reference: parameters, response fields and status codes
  • ✅ Code examples: cURL, JavaScript, Python and Go snippets ready to copy
  • ✅ Authentication walkthrough: API key creation and usage
  • ✅ Rate limits: plan limits and the headers that report your usage
  • ✅ SDKs and MCP: official TypeScript and Python SDKs (@pokewallet/sdk on npm, pokewallet on PyPI) and an MCP server for AI assistants, added in October 2026

As discussed in our API usability guide, documentation quality determines whether developers succeed or abandon your platform.

Infrastructure

  • The API runs on Cloudflare Workers, at the edge, close to your users
  • Card prices are refreshed once a day from TCGPlayer and CardMarket
  • The OpenAPI spec describes every endpoint, so you can generate your own client

We don't publish latency benchmarks or an uptime guarantee: measure response times from your own servers, and cache what you can.

Developer Experience Features

Predictable data structures: Consistent JSON across all endpoints.

Server-side search: Query by name, set or card number, so you don't download 50,000 cards to filter client-side.

Pagination support: Handle large result sets efficiently.

CORS enabled: Call the API from the browser while prototyping (in production, keep your API key on your server).

Rate limit transparency: Always know your quota status via response headers.

PokéWallet vs Competitors

📌 TL;DR: PokéWallet is built around prices: TCGPlayer and CardMarket on every card on the free plan, with price history and set analytics on Pro. TCGdex is the free, no-key option with multilingual card data. PokémonTCG.io is deprecated and shuts down on March 1, 2027.

The Pokémon TCG API landscape has several options, each with different strengths. Here's how PokéWallet compares:

Updated November 2026: this section now reflects the APIs as they are today, with facts about TCGdex and PokémonTCG.io from their own documentation, checked in October 2026. For the full breakdown and sources, see our Pokémon TCG API comparison.

Feature Comparison

FeaturePokéWalletTCGdexPokémonTCG.io
StatusActiveActiveDeprecated: no new keys, shuts down March 1, 2027
AccessFree API keyFree, no keyExisting keys only
Free usage100 requests/hour, 1,000/dayNo published hard limits20,000/day with a key
TCGPlayer pricesYes (USD)Yes (USD)Yes (USD)
CardMarket pricesYes (EUR)Yes (EUR)Yes (EUR)
Price historySnapshots from 7 to 120 days ago (Pro), plus CardMarket averagesCardMarket 1-, 7- and 30-day averagesCardMarket 1-, 7- and 30-day averages
A whole set's prices in one callYes, /prices/:setCode (Pro)Not documentedNo
API typeREST, official SDKs for TypeScript and PythonREST and GraphQLREST
Other gamesOne Piece and ten more, same keyPokémon TCG PocketNo

When to Use Each API

Use PokéWallet if:

  • You need card prices for portfolio, price tracking or shop features
  • You want TCGPlayer and CardMarket side by side, including Japanese sets priced on CardMarket
  • You need price history or set-level prices without collecting them yourself (Pro)
  • You're building a multi-game app with one API key

Use TCGdex if:

  • You don't want to sign up for an API key
  • You need multi-language card data (English, French, Japanese and more)
  • You prefer GraphQL or an open-source data project

PokémonTCG.io:

  • It no longer issues new keys, and existing integrations stop working on March 1, 2027. If you're on it today, plan a migration.

PokéWallet's Differentiators

1. Pricing as a First-Class Feature

PokéWallet treats market prices as core functionality: both marketplaces on every card, refreshed daily, with history and set analytics on top.

2. Developer Experience Priority

We didn't just build an API: we built documentation, examples, SDKs and support that let you ship features instead of debugging infrastructure.

3. Free Tier with Prices

1,000 requests a day on the Free plan, prices included, with paid plans when your app grows.

4. Built to Run in Production

An edge API on Cloudflare Workers, an OpenAPI spec, and rate limit headers on every response, built for real applications serving real users.

We respect and appreciate projects like TCGdex that provide open-source card data to the community. PokéWallet focuses on a complementary challenge: pricing infrastructure and developer-friendly tooling, which requires ongoing investment but remains accessible to builders of all sizes.

What You Can Build

📌 TL;DR: With card data and daily prices from two marketplaces, you can build portfolio trackers, price alert systems, deck builders with cost calculators, investment analysis tools, and store inventory tools.

Here are the kinds of apps the API is designed for:

Collection & Portfolio Trackers

Features you can build:

  • 📊 Daily portfolio valuation: collection worth updates with each daily price refresh
  • 📈 Gain/loss tracking: compare purchase price to current market
  • 🔍 Multi-marketplace comparison: TCGPlayer vs CardMarket prices
  • 📱 Mobile apps: fetch prices on your server, cache them for the day, and keep the app fast
  • 💾 Bulk imports: add entire collections via CSV or manual entry

Technical requirement: users with 500+ card collections. Fetch each card once a day and cache it, or use /prices/:setCode on Pro to price a whole set in one call.

Price Monitoring & Alerts

Features you can build:

  • 🔔 Target price alerts: "Notify me when Charizard drops below $400"
  • 📉 Market movement detection: "Card down 15% on both marketplaces"
  • 🎯 Investment opportunities: "Cards near their 120-day low" (price history, Pro)
  • ⏱️ Daily notifications: email or push alerts after each daily price refresh

Technical requirement: check prices once a day, after the refresh; polling more often won't find new prices.

Deck Builders with Cost Tracking

Features you can build:

  • 💰 Deck valuation: total cost updates as you add cards
  • 🔄 Budget alternatives: "Show cheaper versions of this card"
  • 📊 Meta analysis: what popular tournament decks cost
  • 🎯 Price comparison: "This deck costs $450 on TCGPlayer, €420 on CardMarket"

Technical requirement: card search with prices in the same response, so one call per card is enough.

Market Analysis Tools

Features you can build:

  • 📈 Set performance tracking: set statistics and completion value (Pro)
  • 🔍 Trend detection: cards gaining or losing value, with trending sets and top cards (Pro)
  • 📊 Comparative analysis: Scarlet & Violet vs Mega Evolution price movements
  • 💡 Investment insights: data-driven buying research

Technical requirement: card data plus prices from both marketplaces, and the Pro analytics endpoints for set-level views.

Store Inventory Management

Features you can build:

  • 🏷️ Automated pricing: sync singles prices with market rates every day
  • 📦 Inventory tracking: track stock levels and values
  • 📊 Sales analytics: best-selling cards by set, rarity, type
  • 💵 Buylist optimization: identify trending cards to buy

Technical requirement: set-wide price queries and a daily sync, which /prices/:setCode (Pro) makes simple.

Get Started in Minutes

📌 TL;DR: Sign up free, create an API key from your dashboard, and make your first request in a few minutes. New users start on the Free plan (100 requests/hour, 1,000/day), with no credit card required.

Getting started with PokéWallet API takes three simple steps:

Step 1: Create Your Account

Sign up for free. No credit card required.

What you get immediately:

  • Free plan (100 requests/hour, 1,000/day), with card prices included
  • Access to the full API documentation
  • API key creation
  • A dashboard to monitor your usage

Step 2: Create Your API Key

From your dashboard, create your first API key:

  1. Click "Create Your First Key"
  2. Choose Development (pk_test_) or Production (pk_live_)
  3. Copy your key and store it securely: it's shown only once, and it should never be committed to public repos

Step 3: Make Your First Request

Test your setup with a simple search:

# Search for Charizard cards
curl -H "X-API-Key: pk_live_your_key_here" \
     "https://api.pokewallet.io/search?q=charizard&limit=5"

Expected response (shortened):

{
  "query": "charizard",
  "results": [
    {
      "id": "pk_f45432e30a85f19b...",
      "card_info": { "name": "Charizard", "set_name": "Base Set", "card_number": "004/102" },
      "tcgplayer": { "prices": [ { "sub_type_name": "Holofoil", "market_price": 987.13 } ] },
      "cardmarket": { "prices": [ { "variant_type": "normal", "trend": 411.22 } ] }
    }
  ],
  "pagination": { "page": 1, "limit": 5, "total": 549, "total_pages": 110 }
}

Next Steps

Explore the docs: pokewallet.io/api-docs

Join the community: Discord for developer discussions

Build something: Start with a simple collection tracker or price checker

Share feedback: Tell us what works and what we can improve

Frequently Asked Questions

Is the PokéWallet API really free?

Yes. New users start on the Free plan: 100 requests an hour and 1,000 a day, with no time limit and TCGPlayer and CardMarket prices included. It's a permanent free tier, not a trial. For more volume, Coffee (any amount on Ko-fi), Pro (€20/month, 50,000 requests/day) and Ultra (€29/month, 70,000/day) are available. Learn more about our mission to serve developers of all sizes.

How does PokéWallet compare to tcgdex or pokemontcg.io?

PokéWallet focuses on prices and developer experience. TCGdex is a free, open-source API with multilingual card data and per-card prices, but no set-level price endpoints or price history beyond CardMarket's averages. PokémonTCG.io is deprecated and shuts down on March 1, 2027. PokéWallet has TCGPlayer and CardMarket prices on every card on the free plan, plus price history and set analytics on Pro. See our full comparison.

What programming languages can I use?

Any language that can make HTTP requests. There are official SDKs for TypeScript and Python, and our documentation includes examples in cURL, JavaScript, Python and Go. The REST API also works with PHP, Java, C#, Swift, Kotlin, Ruby and any other language, and the OpenAPI spec lets you generate a client.

How often is pricing data updated?

Prices from TCGPlayer and CardMarket are refreshed daily. Every price row includes an updated_at timestamp, so you can see exactly when it last changed.

Can I use this for a commercial application?

Yes. Our terms allow personal and commercial use. The Free plan works for small apps; for higher-volume commercial use, Pro (50,000 requests/day), Ultra (70,000/day) and Business (custom limits) provide the scale you need.

What happens if I exceed my rate limit?

You'll receive a 429 Too Many Requests response. Limits reset on the next hourly or daily window. Every response includes rate limit headers so you can monitor usage. Caching prices for the day keeps most apps well within the Free plan's 1,000 requests a day during development.

Does PokéWallet have GraphQL support?

No, the API is REST only. Every endpoint is a simple REST call, and the official SDKs and the OpenAPI spec cover the typed-client use cases. If GraphQL is important for your use case, tell us on Discord.

How accurate is the pricing data?

The prices come straight from TCGPlayer and CardMarket, the two largest marketplaces for Pokémon cards, so they're real secondary market prices, not MSRP. They're refreshed daily, and each row shows when it was last updated. As seen in our price tracking evolution analysis, comparing two marketplaces gives a fuller picture than either one alone.

Can I cache API responses?

Yes, we encourage it. Card metadata and set information rarely change, so you can cache them for days. Prices are refreshed once a day, so caching them for several hours, or until the next refresh, loses nothing and saves requests.

What about historical pricing data?

It's available on Pro. /cards/:id/price-history returns TCGPlayer and CardMarket price snapshots from 7, 14, 30, 60 and 120 days ago, with the change for each, for Pokémon cards. CardMarket's 1-, 7- and 30-day averages are also included in every card response on every plan.


Start Building Today

Card data, daily-updated prices from TCGPlayer and CardMarket, a free plan and comprehensive documentation remove the barriers that have held TCG apps back.

Whether you're building your first collection tracker or scaling a production marketplace, PokéWallet gives you the data you need.

What you get with PokéWallet API:

  • 📊 TCGPlayer & CardMarket prices for every card, refreshed daily
  • 📈 Price history for Pokémon cards on Pro, with snapshots from 7 to 120 days ago
  • 🆓 Free plan with 1,000 requests a day
  • 🧰 Official SDKs for TypeScript and Python, plus an MCP server
  • 📚 Comprehensive docs: examples in cURL, JavaScript, Python and Go
  • 💬 Developer community: support on Discord

We're not just launching an API: we're building a platform for the Pokémon TCG developer community. Your feedback shapes our roadmap. Your apps show what's possible.

Stop fighting infrastructure. Start building features.


Get Started Now:

Related Reading: