Parse Title API: Fuzzy Matching for Pokemon Cards

The Problem with Card Data

Users describe cards in countless ways:

• "base set charizard holo"
• "Charizard 4/102 Base Set Unlimited"
• "1999 Charizard Holo Rare"

All refer to the same card! The Parse Title API uses fuzzy matching to find the correct card from natural language descriptions.

Why Parse Title API?

A differentiator: fuzzy title matching with a confidence score is unusual among Pokemon card APIs. This is a competitive advantage for:

• ✅ eBay listing enhancement
• ✅ Marketplace scrapers
• ✅ Bulk card imports
• ✅ Natural language search
• ✅ Collection management apps

Quick Start

curl -X POST https://www.pokemonpricetracker.com/api/v2/parse-title \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"title": "base charizard holo"}'

Response (abridged):

{
  "data": {
    "originalTitle": "base charizard holo",
    "parsed": {
      "cardName": "charizard",
      "setName": "base"
    },
    "matches": [
      {
        "tcgPlayerId": "12345",
        "name": "Charizard",
        "setName": "Base Set",
        "cardNumber": "4",
        "rarity": "Holo Rare",
        "matchScore": 12.4,
        "matchReasons": ["Name matches \"charizard\"", "Set matches \"base\""],
        "prices": { "market": 450.50, "low": 399.00 }
      }
    ]
  },
  "metadata": {
    "confidence": 0.95,
    "processingTimeMs": 42,
    "apiCallsConsumed": 2
  }
}

Use Case: eBay Listing Enhancement

Automatically add pricing data to eBay listings:

const axios = require('axios');

async function enhanceEbayListing(listingTitle) {
  const API_KEY = process.env.POKEMON_API_KEY;

  // Parse the listing title
  const response = await axios.post(
    'https://www.pokemonpricetracker.com/api/v2/parse-title',
    { title: listingTitle },
    {
      headers: {
        'Authorization': `Bearer ${API_KEY}`,
        'Content-Type': 'application/json'
      }
    }
  );

  const { data, metadata } = response.data;

  if (data.matches && data.matches.length > 0) {
    const card = data.matches[0];
    const confidence = metadata.confidence;

    return {
      cardName: card.name,
      setName: card.setName,
      marketPrice: card.prices.market,
      confidence: (confidence * 100).toFixed(0) + '%',
      suggestedPrice: (card.prices.market * 1.1).toFixed(2), // 10% markup
      priceRange: {
        low: (card.prices.market * 0.85).toFixed(2),
        high: (card.prices.market * 1.15).toFixed(2)
      }
    };
  }

  return null;
}

// Example
const listing = "Pokemon Charizard Base Set Holo 4/102";
enhanceEbayListing(listing).then(data => {
  console.log(`Suggested Price: $${data.suggestedPrice}`);
  console.log(`Market Price: $${data.marketPrice}`);
  console.log(`Confidence: ${data.confidence}`);
});

Use Case: Bulk Card Import

Process CSV files with card descriptions:

import pandas as pd
import requests

API_KEY = "your_api_key"
API_BASE = "https://www.pokemonpricetracker.com/api/v2"

def parse_bulk_cards(csv_file):
    df = pd.read_csv(csv_file)
    results = []

    for idx, row in df.iterrows():
        card_description = row['Description']

        response = requests.post(
            f"{API_BASE}/parse-title",
            json={'title': card_description},
            headers={'Authorization': f'Bearer {API_KEY}'}
        )

        if response.ok:
            body = response.json()
            if body['data']['matches']:
                match = body['data']['matches'][0]
                results.append({
                    'Original Description': card_description,
                    'Matched Card': match['name'],
                    'Set': match['setName'],
                    'Market Price': match['prices']['market'],
                    'Confidence': f"{body['metadata']['confidence'] * 100:.0f}%"
                })

    return pd.DataFrame(results)

# Process file
df = parse_bulk_cards('my_cards.csv')
df.to_csv('matched_cards.csv', index=False)
print(f"Processed {len(df)} cards")

React Marketplace Form Component

import React, { useState } from 'react';
import axios from 'axios';

interface ParsedCard {
  name: string;
  setName: string;
  marketPrice: number;
  confidence: number;
}

export function CardPriceChecker() {
  const [description, setDescription] = useState('');
  const [result, setResult] = useState<ParsedCard | null>(null);
  const [loading, setLoading] = useState(false);

  const handleCheck = async () => {
    setLoading(true);
    try {
      const response = await axios.post('/api/parse-card', {
        title: description
      });

      if (response.data.data.matches?.[0]) {
        const match = response.data.data.matches[0];
        setResult({
          name: match.name,
          setName: match.setName,
          marketPrice: match.prices.market,
          confidence: response.data.metadata.confidence
        });
      }
    } catch (error) {
      console.error('Error parsing card:', error);
    } finally {
      setLoading(false);
    }
  };

  return (
    <div className="card-checker">
      <input
        type="text"
        value={description}
        onChange={(e) => setDescription(e.target.value)}
        placeholder="Enter card description..."
        className="input"
      />
      <button onClick={handleCheck} disabled={loading}>
        {loading ? 'Checking...' : 'Check Price'}
      </button>

      {result && (
        <div className="result">
          <h3>{result.name}</h3>
          <p>Set: {result.setName}</p>
          <p>Market Price: ${result.marketPrice.toFixed(2)}</p>
          <p>Confidence: {(result.confidence * 100).toFixed(0)}%</p>
        </div>
      )}
    </div>
  );
}

Confidence Scoring

The API returns a parse confidence score in metadata.confidence (0.0 - 1.0), indicating how confidently the title was parsed. Each match also includes a relevance matchScore and human-readable matchReasons.

Interpreting metadata.confidence:

• 0.9 - 1.0: Excellent match, use with confidence
• 0.7 - 0.9: Good match, likely correct
• 0.5 - 0.7: Moderate match, verify manually
• < 0.5: Poor match, request clarification

Best Practices

1. Always check confidence: Don't blindly use matches below 0.7
2. Handle no matches: Provide user feedback when card isn't found
3. Use specific descriptions: Include set name when possible
4. Batch processing: Group requests to stay within rate limits
5. Cache results: Store successful matches to reduce API calls

API Costs

• Free tier: 100 credits/day
• Parse Title: 2 credits per request (options like fuzzy matching, long titles, or extra suggestions can add 1 credit each)
• Perfect for small-scale apps

Upgrade to API tier ($9.99/mo) for 20,000 credits/day.

Related Tutorials

• Python Pokemon Price Automation
• React Native Card Scanner

Get Free API Key →