Whether you are building an automated repricing tool for a retro game shop, managing a personal collection of rare Nintendo titles, or identifying grading arbitrage in Pokémon TCG cards, PriceCharting is the standard benchmark for historical market values.

PriceCharting aggregates historical sales across eBay, Heritage Auctions, Goldin, PWCC, and TCGPlayer, categorizing items by condition and grading company.

However, extracting this data at scale presents significant friction:

• Manual Lookup is Unsustainable: Checking current values for 500+ game cartridges or graded cards takes dozens of hours and goes stale within days.
• The Official API has Steep Limits: PriceCharting's official API requires a paid plan ($49/month) and omits both price history and product images. It returns only static, current snapshot estimates.
• Scraping is Fragile: PriceCharting blocks standard HTTP requests with 403 Forbidden errors if real browser headers are missing, and pins currencies dynamically based on location unless specific cookies (currency=usd) are supplied.

To solve this, we can use the cloud-hosted PriceCharting Product Scraper on Apify. It extracts current prices across every condition, the full historical time series, complete grading ladders (TAG, ACE, SGC, CGC, PSA, BGS), recent sold comps, and 1600px high-resolution images into clean, structured JSON.

2. The Data Schema: Video Games vs. Trading Cards

PriceCharting structures price points differently depending on whether an item is a video game or a collectible card. The scraper normalizes these points into a consistent, predictable schema.

Standard Price Slots (price)

Full Grading Ladder (fullPrices)

For trading cards, the fullPrices object captures the entire market spectrum:

• Numerical Grades: Grade 1 through 9.5.
• Top Tier Grades: TAG 10, ACE 10, SGC 10, CGC 10, CGC 10 Pristine, PSA 10, BGS 10, and BGS 10 Black Label.

Time Series (priceHistory)

Every headline condition includes its full historical price array ([ [timestamp_ms, price_usd], ... ]), enabling trend analysis and rolling averages without querying secondary databases.

3. Extracting PriceCharting Records with Python

Using the official apify-client Python package, you can query one or hundreds of PriceCharting items in parallel.

Prerequisites

pip install apify-client pandas matplotlib seaborn

Python Extraction Script

import os
import pandas as pd
from apify_client import ApifyClient

# Initialize Apify client with your API token
client = ApifyClient(os.environ.get("APIFY_API_TOKEN") or "YOUR_APIFY_TOKEN")

# Target PriceCharting product URLs or numeric IDs
run_input = {
    "productUrls": [
        "https://www.pricecharting.com/game/gameboy-advance/pokemon-emerald",
        "https://www.pricecharting.com/game/pokemon-base-set/charizard-4"
    ],
    "scrapeProductDetails": True,
    "includeRecentSales": True
}

print("[*] Launching PriceCharting Product Scraper...")
run = client.actor("incognito_mode/pricecharting-product-scraper").call(run_input=run_input)

# Retrieve dataset items
dataset = client.dataset(run["defaultDatasetId"])
products = list(dataset.iterate_items())

for item in products:
    name = item.get("productName")
    console = item.get("consoleName")
    prices = item.get("price", {})
    print(f"
Product: {name} ({console})")
    print(f" - Loose / Raw: ${prices.get('loose')}")
    print(f" - CIB / Grade 7: ${prices.get('cib')}")
    print(f" - New / Grade 8: ${prices.get('new')}")
    print(f" - Graded / Grade 9: ${prices.get('graded')}")
    print(f" - PSA 10 / Manual: ${prices.get('manualOnly')}")

4. Practical Data Science: Grading Arbitrage & Price Divergence

One of the most valuable applications of this structured data is identifying grading arbitrage: determining when the premium of a PSA 10 or BGS 9.5 justifies the grading fee and risk of submitting a raw card.

Here is how you can process the extracted JSON in Pandas to calculate the Grading Multiplier:

# Load extracted items into a DataFrame
df = pd.DataFrame(products)

# Extract price columns
df["raw_price"] = df["price"].apply(lambda p: p.get("loose") if isinstance(p, dict) else None)
df["psa10_price"] = df["price"].apply(lambda p: p.get("manualOnly") if isinstance(p, dict) else None)

# Calculate multiplier: PSA 10 Value / Raw Card Value
df["psa10_multiplier"] = df["psa10_price"] / df["raw_price"]

print(df[["productName", "raw_price", "psa10_price", "psa10_multiplier"]])

When a card exhibits a 15x or 20x multiplier between raw condition and PSA 10, mint-condition raw copies offer significant positive expected value (EV) for professional grading.

5. Google Sheets Integration (No-Code Workflow)

If you manage inventory or track your collection in Google Sheets, you can import live PriceCharting data without writing a single line of backend code:

1. In the Apify Console, navigate to your finished scraper run dataset.
2. Copy the permanent CSV API URL:

https://api.apify.com/v2/datasets/<DATASET_ID>/items?format=csv

1. In any Google Sheet cell, enter:

=IMPORTDATA("https://api.apify.com/v2/datasets/<DATASET_ID>/items?format=csv")

Google Sheets will automatically populate rows with product names, loose prices, CIB prices, and recent sales volumes.

6. Key Takeaways

• Bypass Official API Gaps: Get full historical time series, high-resolution 1600px box/card photos, and actual sold comps that the official $49/mo API lacks.
• Pay Only for Successful Results: Failed lookups or invalid URLs are excluded from the dataset and never billed.
• Analysis-Ready Output: Clean USD numeric values ready for Pandas, SQL databases, and spreadsheet modeling.

To run this scraper yourself, check out the PriceCharting Product Scraper on Apify.

The problem is getting that data out in bulk. FotMob doesn't have an open public API. If you're building a predictive model, a fantasy sports tool, a scouting dashboard, or just running weekly analytics, clicking through hundreds of matches by hand is out of the question. At 2 minutes per match, pulling a 500-game dataset takes over 16 hours of manual copying.

Scraping it directly isn't straightforward either. FotMob's web frontend relies on internal API endpoints protected by dynamic request signatures (x-mas headers) and changing payload structures. Scrapers built from scratch usually break after a few weeks. Meanwhile, commercial sports data feeds like Opta, StatsBomb, or Sportradar cost hundreds or thousands of dollars a month and gatekeep advanced stats like xG behind enterprise plans.

To solve this, I built a reliable scraper on Apify: the FotMob Match Details Scraper. It takes a list of FotMob match IDs or URLs and outputs one normalized JSON or CSV record per match in seconds.

Here is a quick walkthrough of how it works, what the data structure looks like, and how to integrate it into Python or Google Sheets.

What the Extracted Dataset Contains

Each match produces a structured object with the following fields:

• Match Header & Meta: Home and away clubs, final score, kickoff timestamp in UTC (ISO 8601), competition, matchday/round, country, match status (started, finished), venue, referee, attendance, and official Player of the Match.
• lineups: Tactical formations for both clubs (e.g. 4-3-3, 4-2-3-1), manager/coach names, starting XI with shirt numbers and positions, and full bench lists.
• playerStats: Flattened, analysis-ready stats for every player who took the pitch: FotMob rating, minutes played, goals, assists, expected goals (expected_goals), expected assists (expected_assists), total shots, passing accuracy, chances created, touches, duels won, clearances, and goalkeeper metrics (saves, goals conceded).
• events: A unified, chronological log of all primary match events: goals (including goal type and assist), yellow/red cards, and substitutions with incoming and outgoing player names and exact minute marks.
• teamStats: Full head-to-head comparison categories: possession, xG, total shots, shots on target, accurate passes, duels, tackles, fouls, corners, and offsides.
• h2h (optional): Previous head-to-head records between the two clubs.
• rawData (optional): The raw, unparsed FotMob JSON payload for cases where you need internal IDs or debugging.

Step 1: Set Up the Scraper

1. Go to the FotMob Match Details Scraper on Apify.
2. If you don't have an Apify account, you can sign up for free (the free tier includes $5/month in credit, which covers roughly 500 match extractions each month).
3. Open the actor and navigate to the Input tab.

Step 2: Provide Match IDs or URLs

In the Match ids or URLs input field, enter one ID or link per line. The actor accepts numeric IDs, short match links, or full fixture URLs:

4506324
https://www.fotmob.com/match/4506324
https://www.fotmob.com/matches/aston-villa-vs-manchester-united/2pj9x9#4506324

To find a match ID manually, open any match on FotMob in your browser. The digits at the end of the URL (e.g. fotmob.com/match/4506324) are the ID.

If you need match IDs in bulk, you can chain this actor with the FotMob Matches Scraper (which pulls all matches by calendar date) or the FotMob League Scraper (which dumps fixture lists for an entire league season).

Step 3: Configure Settings

You can toggle individual data blocks to keep payloads compact and speed up execution:

• Include player stats: Keep enabled if you need per-player ratings and metrics.
• Include events timeline: Keep enabled for goals, cards, and sub logs.
• Include lineups: Formations, managers, starting XI, and substitutes.
• Include team stats: Aggregate match stats (xG, possession, passes, fouls).
• Include head-to-head history: Historical meetings (leave off unless compiling match previews).
• Include raw data: Full unparsed response (leave off unless you need raw internal fields).

Here is the equivalent JSON payload if you use the API or JSON editor:

{
  "matchIds": [
    "4506324",
    "https://www.fotmob.com/match/4506324"
  ],
  "includePlayerStats": true,
  "includeEvents": true,
  "includeLineups": true,
  "includeTeamStats": true,
  "includeH2H": false,
  "includeRawData": false
}

Step 4: Run the Scraper and Inspect Output

Click Save & Start.

A single match finishes in 2–3 seconds. Batches of 50 to 100 matches typically finish in 1 to 2 minutes.

A practical detail about billing: failed lookups are completely free. If you accidentally submit an invalid match ID, an unplayed fixture that won't load, or a broken URL, the actor logs the failure in the SUMMARY store and skips writing to the dataset. You are never billed for non-existent matches or failed lookups.

Here is a trimmed real-world output sample from Aston Villa vs Manchester United (4506324):

{
  "matchId": 4506324,
  "matchName": "Aston Villa-vs-Manchester United_Sun, Oct 6, 2024, 13:00 UTC",
  "matchUrl": "https://www.fotmob.com/match/4506324",
  "leagueId": 47,
  "leagueName": "Premier League",
  "round": "7",
  "countryCode": "ENG",
  "matchTimeUtc": "2024-10-06T13:00:00.000Z",
  "started": true,
  "finished": true,
  "homeTeam": { "id": 10252, "name": "Aston Villa", "score": 0 },
  "awayTeam": { "id": 10260, "name": "Manchester United", "score": 0 },
  "venue": "Villa Park",
  "referee": "Robert Jones",
  "attendance": 42682,
  "playerOfTheMatch": {
    "playerId": 268375,
    "name": "Emiliano Martinez",
    "teamName": "Aston Villa"
  },
  "teamStats": [
    { "group": "Top stats", "title": "Ball possession", "key": "BallPossesion", "home": 54, "away": 46 },
    { "group": "Top stats", "title": "Expected goals (xG)", "key": "expected_goals", "home": "0.50", "away": "0.56" },
    { "group": "Top stats", "title": "Total shots", "key": "total_shots", "home": 11, "away": 10 },
    { "group": "Passes", "title": "Accurate passes", "key": "accurate_passes", "home": "345 (83%)", "away": "302 (82%)" }
  ],
  "events": [
    {
      "type": "Card",
      "minute": 3,
      "minuteLabel": 3,
      "isHome": false,
      "playerId": 157723,
      "playerName": "Christian Eriksen",
      "card": "Yellow"
    },
    {
      "type": "Substitution",
      "minute": 12,
      "isHome": true,
      "playersInvolved": ["Diego Carlos", "Ezri Konsa"]
    }
  ],
  "lineups": {
    "home": {
      "teamId": 10252,
      "teamName": "Aston Villa",
      "formation": "4-4-1-1",
      "coach": "Unai Emery",
      "starters": [
        { "playerId": 268375, "name": "Emiliano Martinez", "shirtNumber": "23", "position": "Keeper" }
      ],
      "subs": []
    },
    "away": {
      "teamId": 10260,
      "teamName": "Manchester United",
      "formation": "4-2-3-1",
      "coach": "Erik ten Hag",
      "starters": [],
      "subs": []
    }
  },
  "playerStats": [
    {
      "playerId": 268375,
      "name": "Emiliano Martinez",
      "teamId": 10252,
      "teamName": "Aston Villa",
      "shirtNumber": "23",
      "position": "Keeper",
      "isGoalkeeper": true,
      "rating_title": 8.36,
      "minutes_played": 90,
      "saves": 4,
      "goals_conceded": 0,
      "accurate_passes": "24/32 (75.0%)",
      "touches": 40
    }
  ],
  "source": "fotmob-match-details-scraper",
  "scrapedAt": "2026-06-18T11:11:32+00:00"
}

Notice a few design choices in the schema:

1. Flattened player statistics: Instead of nested UI component hierarchies, each player has clean key-value pairs (rating_title, minutes_played, expected_goals, touches), so you can load the list directly into a Pandas DataFrame or SQL database.
2. Sequential event logs: Substitutions, cards, and goals are chronologically unified in events so you don't need multiple lookups to reconstruct the flow of a match.
3. State handling: For upcoming fixtures, lineups appear as soon as FotMob confirms them, while in-game stats remain omitted until kickoff.

Step 5: Connecting to Python & Spreadsheets

Python (apify-client)

To automate regular data pulls or integrate the scraper into your pipeline, install the official client:

pip install apify-client

Then trigger the actor and iterate over items directly:

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run_input = {
    "matchIds": [
        "4506324",
        "https://www.fotmob.com/match/4506324",
    ],
    "includePlayerStats": True,
    "includeEvents": True,
    "includeLineups": True,
    "includeTeamStats": True,
}

run = client.actor("incognito_mode/fotmob-match-details-scraper").call(run_input=run_input)

for match in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"Match: {match['homeTeam']['name']} {match['homeTeam']['score']} - {match['awayTeam']['score']} {match['awayTeam']['name']}")
    
    # Filter players with high match ratings
    for player in match.get("playerStats", []):
        if player.get("rating_title", 0) >= 8.0:
            print(f"  {player['name']} ({player['teamName']}): Rating {player['rating_title']} | Minutes: {player['minutes_played']}")

Google Sheets Integration

If you prefer working in spreadsheets, you can use Google Sheets' =IMPORTDATA() with the actor dataset's clean CSV export URL:

=IMPORTDATA("https://api.apify.com/v2/datasets/<DATASET_ID>/items?format=csv&clean=true&token=<YOUR_APIFY_TOKEN>")

Pricing & Running Costs

The actor runs on a pay-per-event pricing model with automatic volume tiers:

• $0.01 per match ($10 per 1,000 matches) for the first 10,000 matches in a single run.
• $0.006 per match ($6 per 1,000 matches) for matches beyond 10,000 in a run.
• A $0.02 start fee per run.
• Failed or missing fixtures cost $0.00.

At these rates:

• Scraping a 10-game Premier League weekend costs around $0.12.
• A full 380-match domestic season runs about $3.82.
• The free $5/month credit provided on Apify accounts covers roughly 500 complete match breakdowns every month.

Summary

If you need comprehensive football data without paying for commercial data vendor subscriptions or dealing with fragile custom scrapers that break when website headers change, this actor provides a solid, maintenance-free solution.

You can try it out directly on Apify: FotMob Match Details Scraper.