DEV Community: Arman Hosen

How to Turn FotMob Matches Into Clean JSON: Lineups, Per-Player Stats, Events Timeline & xG

Arman Hosen — Fri, 04 Sep 2026 20:35:00 +0000

A step-by-step guide to exporting full match details, team formations, per-player stats and ratings, goal/card/substitution timelines, and head-to-head xG comparisons for any football match — by match ID or URL, with no scraping code required.

The problem: Football data is rich, but trapped in mobile apps and scattered web pages

FotMob is one of the cleanest, fastest, and most comprehensive football tracking platforms in the world. Whether it's the Premier League, Champions League, La Liga, MLS, or lower-tier domestic competitions, FotMob packs an enormous amount of deep data into every single fixture: confirmed tactical formations, live match ratings, expected goals (xG) shot breakdowns, player of the match honors, and granular event timelines.

The catch: you can only explore it one match at a time in a browser or mobile app. If you are:

a football data analyst or sports scientist looking to model team performance and player tendencies,
a predictive modeler or sports bettor looking for quantitative edge through historical xG, shot volumes, and duel success rates,
a fantasy manager or scouting tool builder tracking player form, minutes, and statistical outputs across fixtures,
a content creator, newsletter writer, or sports journalist looking for instant post-match stat cards and tactical timelines, or
a developer building a Discord bot, mobile app, or personal dashboard —

…then manually copying numbers off the screen is impossible at scale. Pulling 500 weekend matches by hand at 2 minutes per match takes over 16 hours of clicking. Meanwhile, enterprise sports data feeds (Opta, StatsBomb, Sportradar) charge hundreds to thousands of dollars per month and strictly gatekeep xG and player ratings behind expensive tiers.

Scraping FotMob directly yourself isn't much easier either: data is fragmented across dynamic client-side bundles, internal endpoints, and request signature headers (x-mas) that frequently break custom scrapers.

This tutorial shows a faster, painless alternative: input a list of match IDs or URLs and get back one clean, normalized JSON (or CSV/Excel) record per match — complete with scorelines, formations, per-player stats, ordered event timelines, and team comparisons — in a single automated run that finishes in minutes and costs pennies (with a free monthly tier that covers ~500 matches).

We’ll use the FotMob Match Details Scraper on Apify. No coding is required for the standard workflow, and we've included quick Python and API snippets at the end if you want to pipe the data directly into your analytical stack.

What you'll get (per match)

Each match returns as one structured record containing:

Match header & status — home/away teams, final score, kickoff time in UTC (ISO 8601), competition, matchday/round, country, status (started, finished), venue, referee, attendance, and official Player of the Match.
lineups — both teams' tactical formations (e.g. 4-3-3, 4-2-3-1), head coach, starters, and bench with shirt numbers and designated positions.
playerStats — flattened, analysis-ready stats for every player who featured: rating_title, minutes played, goals, assists, expected goals (expected_goals), expected assists (expected_assists), total shots, accurate passes ("34/40 (85.0%)"), chances created, touches, duels won, clearances, and goalkeeper stats (saves, goals_conceded).
events — an ordered, chronological timeline of every key match event: goals (with goalType and assist), cards (yellow/red), and substitutions (with incoming/outgoing players and exact minute labels).
teamStats — the full head-to-head comparison table categorized into clear groups: Top stats, Shots, Expected goals (xG), Passes, Defence, Duels, and Discipline.
h2h (opt-in) — historical head-to-head meetings between the two clubs.
rawData (opt-in) — the complete, unparsed FotMob JSON payload for advanced users needing internal metadata.

Export everything into JSON, CSV, Excel, XML, or fetch via API.

What you'll need

A free Apify account — the free plan includes $5/month in platform credit (covering roughly 500 full match breakdowns every month), no credit card required.
The Actor: FotMob Match Details Scraper.
A list of FotMob match IDs or URLs (we'll cover how to find them or generate them in bulk).

Step 1 — Open the Actor

Go to the FotMob Match Details Scraper on Apify and click Try for free. If you're not signed in, create your free account, and you'll immediately land on the Actor console with the input screen ready.

Step 2 — Add your match IDs or URLs

In the Match ids or URLs field, add one entry per line. The Actor accepts numeric IDs, direct match URLs, or anchor URLs interchangeably:

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

How to find match IDs: Open any match on FotMob in your web browser. The numeric string in the URL (e.g. fotmob.com/match/4506324) is the match ID.

Need match IDs in bulk? You don't have to look them up manually. Run the FotMob Matches Scraper (to pull all match IDs by calendar date) or the FotMob League Scraper (to pull an entire season's fixture schedule). Both actors emit matchIds that pipe directly into this Actor.

Step 3 — Choose your options (defaults are fine)

The Actor provides independent toggles so you can control payload size, speed, and cost:

Option	What it does	Recommended
Include player stats	Extracts per-player ratings, minutes, passes, duels, shots & xG	Leave On (turn off only if you strictly need team totals)
Include events timeline	Adds chronological goals, assists, cards, and substitutions	Leave On
Include lineups	Adds formations, coaches, starting XI, and bench players	Leave On
Include team stats	Head-to-head stat table (possession, xG, shots, passes, fouls)	Leave On
Include head-to-head history	Adds previous meetings between the two sides	Off unless doing historical matchup previews
Include raw data	Appends FotMob's entire unparsed JSON response	Leave Off (significantly balloons dataset size)
Proxy configuration	Network routing through Apify Proxy	Leave Automatic / Datacenter (default is fast and reliable)
Max concurrency / Delay	Controls scraping speed and politeness	Defaults (`5` concurrency / `1s` delay) work smoothly
Max items	Stops run after N matches	`0` = unlimited

If you prefer using the JSON editor tab on Apify, here is the equivalent payload:

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

Step 4 — Run it

Click Save & Start.

The Actor launches and begins streaming parsed match records into your default dataset. A single match finishes in 2–3 seconds; batches of 50 to 100 matches complete in 1 to 2 minutes.

One critical detail: Failed lookups are 100% free. If you accidentally submit an invalid match ID, a postponed match that won't load, or a typo in the URL, that entry is not written to your dataset and you are never billed for it. Any problematic inputs are transparently captured in the SUMMARY record inside your Key-Value Store so you can inspect them without paying a dime.

Step 5 — Read the output (the important part)

Head over to the Dataset tab. You can view the tabular view or switch to raw JSON.

Here is a trimmed real-world output from the Premier League clash between Aston Villa and 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%)" }
    // … grouped by Shots, Passes, Defence, Duels, Discipline
  ],
  "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"]
    }
    // … goals include goalType, scorer, and assist
  ],
  "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" }
        // … all 11 starters
      ],
      "subs": [ /* bench players */ ]
    },
    "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
    }
    // … one complete flattened stats object per player who stepped on the pitch
  ],
  "source": "fotmob-match-details-scraper",
  "scrapedAt": "2026-06-18T11:11:32+00:00"
}

Three key things to note about this schema:

Player statistics are flattened for analysis. Many scrapers dump deeply nested UI trees for player cards. This Actor flattens them into clean, standardized key-value pairs (rating_title, minutes_played, expected_goals, touches, chances_created), making it trivial to load into a Pandas DataFrame or SQL table without data wrangling.
Events are chronologically unified. Substitutions, cards, and goals live together in the events array in exact game order. You don't have to query players to find out who was subbed off in the 12th minute.
Status-aware data. For scheduled upcoming matches, the Actor returns confirmed lineups and formations as soon as FotMob publishes them, while omitting playerStats until the match kicks off.

Step 6 — Export and integrate

No-code: Spreadsheets & Live Google Sheets

From the Apify Console Dataset tab, click Export to download your records as CSV, Excel (XLSX), JSON, or XML.

To pull live match data into Google Sheets without exporting files manually, use the dataset's direct CSV endpoint with =IMPORTDATA():

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

(Keep your Apify API token private or create a read-only token under your Apify Integrations settings).

Python: Automate workflows with `apify-client`

Install the official Python client:

pip install apify-client

Trigger the Actor and iterate over player stats and xG values directly in Python:

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)

# Stream parsed dataset items
for match in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"Match: {match['homeTeam']['name']} {match['homeTeam']['score']} - {match['awayTeam']['score']} {match['awayTeam']['name']}")
    print(f"Player of the Match: {match.get('playerOfTheMatch', {}).get('name')}")

    # Extract top 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']}")

cURL: One-shot synchronous API run

If you want to trigger a run from an external backend or serverless function and immediately receive the dataset items in response:

curl -X POST \
  "https://api.apify.com/v2/acts/incognito_mode~fotmob-match-details-scraper/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{
    "matchIds": ["4506324"],
    "includePlayerStats": true,
    "includeTeamStats": true
  }'

Automating with Schedules & Webhooks

Daily / Weekly Schedules: Set an Apify Schedule to run every Sunday evening or Monday morning to automatically collect all weekend match stats.
Webhooks: Configure a webhook to POST the completed dataset to your webhook endpoint, Zapier, Make, or Discord bot whenever a run finishes.

What it costs

The Actor uses transparent, predictable pay-per-event pricing with an automatic volume discount — no recurring subscription fees, no locked contracts, and zero charges for failed requests:

$0.01 per match ($10.00 per 1,000 matches) for the first 10,000 matches in a run.
$0.006 per match ($6.00 per 1,000 matches) for every match beyond 10,000 in a single run (40% volume discount).
A minimal $0.02 Actor start fee per run.
Failed lookups cost $0.00 — you never pay for non-existent matches, broken links, or cancelled fixtures.

Real-world cost examples:

Analyzing a 10-match Premier League matchday ≈ $0.12
Processing a 50-match weekend slate across top European leagues ≈ $0.52
Scraping a full 380-match season with all lineups, xG, and player ratings ≈ $3.82
Scraping 15,000 global fixtures across a season ≈ $130.02

The $5.00/month free platform credit on Apify covers ~500 full match breakdowns completely free every month. Compared to commercial sports data feeds charging $300–$1,500/month for xG and event data, this represents unmatched flexibility.

You can also set a Maximum charge per run in the Apify Console. If your run reaches your specified budget, it terminates cleanly and preserves every record already collected.

Tips, limits & responsible use

Combine with the discovery actors: The cleanest automated pipeline is a 2-step chain:
1. Run FotMob Matches Scraper (by date) or FotMob League Scraper (by competition).
2. Map the output matchIds straight into the FotMob Match Details Scraper for deep extraction.
Payload sizing: If you're building high-volume databases and don't need historical head-to-head records or raw JSON, leave includeH2H and includeRawData off. This keeps records lightweight and transfers fast.
Stay respectful: Keep concurrency moderate (5–10) and maintain the default 1-second delay.
Disclaimer: This Actor is intended for personal analysis, research, and data integration. Ensure your usage complies with applicable terms of service and law. This project is not affiliated with, endorsed by, or sponsored by FotMob.

Wrap-up

That’s the complete pipeline: input match IDs or URLs → run → get structured JSON/CSV with verified scorelines, starting formations, xG stats, player ratings, and minute-by-minute match events.

Whether you're developing predictive models, tracking fantasy players, or building a live football dashboard, it replaces fragile DIY scrapers and four-figure API subscriptions with a dependable, pay-as-you-go workflow.

Try it out on this weekend's matches: FotMob Match Details Scraper on Apify.

Have a specific field you'd like added or feedback on the schema? Open an issue from the Actor's Issues tab on Apify!

How to Turn PriceCharting Pages Into Clean JSON: Prices, PSA/BGS/CGC Grades, History & Sold Comps

Arman Hosen — Tue, 16 Jun 2026 13:14:26 +0000

A step-by-step guide to exporting current prices, the full grading ladder, the price-history series, recent sold listings, and 1600px images for any video game, trading card, comic, or coin — by URL or ID, with no scraping code required.

The problem: PriceCharting data is rich, but trapped one page at a time

PriceCharting is the reference price guide for collectibles — video games, Pokémon / Magic / Yu-Gi-Oh! cards, comics, coins, Funko Pops, LEGO sets. Every product page is dense: the current price for each condition, a full grading ladder (PSA, BGS, CGC, SGC, TAG, ACE), an interactive price-history chart, recent sold listings, and a population (POP) report.

The catch: you see it one product at a time, in a browser. If you're:

a reseller or game/card shop repricing inventory,
a collector who wants their collection's value and its trend,
an eBay / marketplace seller checking comps before listing, or
a developer or analyst who needs this in a database, sheet, or dashboard —

…then copy-pasting from the site is the bottleneck. Valuing a 1,000-item collection by hand at ~30 seconds per lookup is roughly eight hours of clicking. And PriceCharting's official API requires the $49/month plan while still returning no price history, no images, and no graded ladder.

This tutorial shows a faster path: paste a list of product URLs or numeric IDs and get back one clean JSON (or CSV/Excel) record per item — every price, the full grade ladder, the complete history series, sold comps, the POP report, and full-resolution images — in a single run that takes minutes and costs a few dollars (with a free tier that covers ~1,000 products).

We'll use the PriceCharting Product Scraper on Apify. No code is needed for the basic path; there's an optional code/Sheets section at the end for automation.

What you'll get (per product)

Each product comes back as one record containing:

Current price for every condition slot — Loose/CIB/New/Graded/Box-only/Manual-only for games; Ungraded → PSA 10 tiers for cards.
fullPrices — the complete grading ladder, with PriceCharting's own labels: Ungraded, Grade 1…Grade 9.5, and the company-specific top grades — TAG 10, ACE 10, SGC 10, CGC 10, CGC 10 Pristine, PSA 10, BGS 10, BGS 10 Black. (Neither the official API nor most scrapers return these.)
priceHistory — the entire time series behind the chart (often hundreds of dated points), per condition.
recentSales (opt-in) — the actual recent sold listings per grade: date, title, final sale price, marketplace (eBay / TCGPlayer / Goldin / PWCC / Heritage), and a clean link — the raw comps behind every price.
salesVolume and populationReport — per-grade sold counts, and the PSA/CGC population chart for cards.
Full-resolution images — the cover plus every gallery photo as direct 1600px URLs.
Catalog metadata — name, console/set, category, release date, UPC, and more.

Export it all as JSON, CSV, Excel, or via API.

What you'll need

A free Apify account — the free plan includes about $5/month of platform credit (roughly 1,000 products with this Actor), and you can start without a credit card.
The Actor: PriceCharting Product Scraper.
A list of PriceCharting product URLs or numeric IDs (we'll cover how to get them).

Step 1 — Open the Actor

Open the PriceCharting Product Scraper and click Try for free. If you're not signed in, Apify will prompt you to create a free account, then drop you on the Actor's input screen.

Step 2 — Add your products

In the Products field, add one entry per line. Each entry is either a full product-page URL or a bare numeric product ID — you can mix them freely:

https://www.pricecharting.com/game/super-nintendo/super-mario-world
https://www.pricecharting.com/game/pokemon-base-set/charizard-4
7141

How to find a product URL or ID: search for the item on PriceCharting and open its page — the URL in your address bar is the first option. For the numeric ID, hover over the product title on its page and the ID appears (it's also in fullPrices/exports later). URLs are easiest; numeric IDs are the most stable for large, repeated runs.

Step 3 — Choose your options (defaults are fine)

Option	What it does	Recommended
Scrape full product details	Includes the full price-history series	Leave on (turn off only if you want current prices only and a lighter result)
Include recent sold listings	Adds `recentSales` (the actual comps) — increases item size ~5×	On if you want comps; otherwise off
Proxy configuration	Network routing	Leave Automatic (cheapest and reliable; switch to Residential only if you ever see failures)
Max concurrency / Delay	Speed vs. politeness	Leave defaults (3 / 1s) for normal runs
Max items	Stop after N results	`0` = unlimited

If you prefer the JSON input tab, here's the equivalent:

{
  "products": [
    "https://www.pricecharting.com/game/pokemon-base-set/charizard-4",
    "7141"
  ],
  "scrapeProductDetails": true,
  "includeRecentSales": false,
  "proxyConfiguration": { "useApifyProxy": true }
}

Step 4 — Run it

Click Save & Start. The run streams results as it goes; a small list finishes in seconds, larger lists in minutes. When it's done, the status line tells you how many products succeeded.

One nice detail: failed lookups are free. A dead link, typo, or removed product isn't written to your dataset and isn't billed — it's listed in the run's SUMMARY record (in the Key-value store) so you can review and retry. You pay only for product records you actually receive.

Step 5 — Read the output (the important part)

Open the Dataset tab to see one row per product, or switch to the JSON view for the full structure. Here's a trimmed example for a Charizard card:

{
  "productId": 630417,
  "productName": "Charizard #4",
  "consoleName": "Pokemon Base Set",
  "category": "pokemon-cards",
  "url": "https://www.pricecharting.com/game/pokemon-base-set/charizard-4",
  "imageUrl": "https://storage.googleapis.com/images.pricecharting.com/<hash>/1600.jpg",
  "images": ["…/1600.jpg", "…/1600.jpg"],
  "currency": "USD",
  "prices": {
    "loose": 338.42,       // Ungraded
    "cib": 749.50,         // Grade 7
    "new": 1199.03,        // Grade 8
    "graded": 3175.04,     // Grade 9
    "boxOnly": 3403.50,    // Grade 9.5
    "manualOnly": 30085.73 // PSA 10
  },
  "fullPrices": {          // the complete on-page ladder, labels verbatim
    "Ungraded": 338.42,
    "Grade 9": 3175.04, "Grade 9.5": 3403.50,
    "SGC 10": 18051.00, "CGC 10": 7605.63, "PSA 10": 30085.73,
    "BGS 10": 39111.00, "BGS 10 Black": 195555.00,
    "TAG 10": null        // grade tracked, no recorded sales yet
  },
  "salesVolume": { "Ungraded": 48, "PSA 10": 30, "Grade 9": 30 },
  "populationReport": {
    "PSA": { "9": 9, "10": 0 },
    "CGC": { "9": 2, "10": 4 }
  },
  "priceHistory": {
    "used":   [ { "date": "2020-09-01", "price": 180.00 }, { "date": "2020-10-01", "price": 210.50 } ],
    "graded": [ { "date": "2021-01-01", "price": 2600.00 } ]
  },
  "source": "scrape",
  "scrapedAt": "2026-06-11T04:24:21+00:00"
}

The one thing to understand — the six price slots are category-specific. PriceCharting reuses the same six columns with different labels depending on the product, so the Actor keeps stable keys and you read them per category:

Stable key	Video games	Trading cards
`prices.loose`	Loose (cart/disc only)	Ungraded
`prices.cib`	Complete in box	Grade 7
`prices.new`	New / sealed	Grade 8
`prices.graded`	Graded	Grade 9
`prices.boxOnly`	Box only	Grade 9.5
`prices.manualOnly`	Manual only	PSA 10

priceHistory mirrors these keys, with one quirk: the first slot's history key is used (not loose); the other five match. So for a card, priceHistory.manualOnly is the PSA 10 price over time and priceHistory.used is the Ungraded series. If the six slots aren't enough, read fullPrices — it carries the complete labeled ladder (every grading company), no mapping needed. (History exists only for the six headline slots; the company-specific grades are current market values, because PriceCharting publishes no time series for them.)

Step 6 — Export and integrate

No code — spreadsheet users:

In the Dataset tab, click Export and download CSV or Excel.
Or pull results live into Google Sheets with the dataset's CSV endpoint:

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

The token in that URL grants API access to your account — keep the Sheet private and, ideally, use a limited-scope token.

With code — Python (apify-client): run the Actor and read results in one script.

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run_input = {
    "products": [
        "https://www.pricecharting.com/game/pokemon-base-set/charizard-4",
        "7141",
    ],
    "scrapeProductDetails": True,
    "includeRecentSales": False,
}

run = client.actor("incognito_mode/pricecharting-product-scraper").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["productName"], "→ PSA 10:", item["prices"]["manualOnly"])

With code — one-shot via the API (curl): run synchronously and get the dataset items back in the response.

curl -X POST \
  "https://api.apify.com/v2/acts/incognito_mode~pricecharting-product-scraper/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"products":["https://www.pricecharting.com/game/pokemon-base-set/charizard-4","7141"]}'

Automate it: use Apify Schedules to re-run daily or weekly (build your own price-history dataset over time), and webhooks to push each finished run into your pipeline — Sheets, Slack, or your backend.

What it costs

The Actor uses transparent pay-per-result pricing with a built-in volume discount — no subscription, no minimums, and no charge for failures:

$5.00 per 1,000 results for the first 10,000 of a run.
$1.50 per 1,000 for everything beyond that (the discount resets per run, so one big run is cheaper than many small ones).
A small Actor-start fee per run.

So valuing 50 cards ≈ $0.27, repricing a 500-item inventory ≈ $2.50, and 1,000 products with full history + images ≈ $5 — and the free plan's ~$5/month credit covers about that first 1,000 before you pay anything. Compare that to the official API's $49/month that still ships no history, no images, and no graded ladder. (Check the Actor page for current pricing.)

You can also set a maximum charge per run — the Actor stops gracefully at your cap and keeps everything already scraped.

Tips, limits & responsible use

Bulk runs (10k+): input bare numeric IDs (hundreds of thousands fit in one run), raise concurrency to 10–15, set the timeout to unlimited, and export promptly — datasets get large with history on.
Comps add size: recentSales roughly 5×'s each record; leave it off if you only need prices.
Scope: v1 takes individual product URLs/IDs; whole-set/console bulk mode is on the roadmap.
Be respectful: keep concurrency low and delays reasonable. This project isn't affiliated with PriceCharting; for high-volume commercial use, their official paid API (token mode) is the sanctioned source, and you're responsible for complying with their Terms.

Wrap-up

That's the whole loop: paste URLs or IDs → run → export clean JSON/CSV with every grade, the full history, comps, POP, and images. Whether you're repricing inventory, tracking a collection's trend, or feeding an app, it turns hours of manual lookups into a few-minute run.

Try it on a handful of your own products: PriceCharting Product Scraper. Questions or a field you need? Open an issue from the Actor's Issues tab — feedback shapes the roadmap.

DEV Community: Arman Hosen

How to Turn FotMob Matches Into Clean JSON: Lineups, Per-Player Stats, Events Timeline & xG

The problem: Football data is rich, but trapped in mobile apps and scattered web pages

What you'll get (per match)

What you'll need

Step 1 — Open the Actor

Step 2 — Add your match IDs or URLs

Step 3 — Choose your options (defaults are fine)

Step 4 — Run it

Step 5 — Read the output (the important part)

Three key things to note about this schema:

Step 6 — Export and integrate

No-code: Spreadsheets & Live Google Sheets

Python: Automate workflows with apify-client

cURL: One-shot synchronous API run

Automating with Schedules & Webhooks

What it costs

Real-world cost examples:

Tips, limits & responsible use

Wrap-up

How to Turn PriceCharting Pages Into Clean JSON: Prices, PSA/BGS/CGC Grades, History & Sold Comps

The problem: PriceCharting data is rich, but trapped one page at a time

What you'll get (per product)

What you'll need

Step 1 — Open the Actor

Step 2 — Add your products

Step 3 — Choose your options (defaults are fine)

Step 4 — Run it

Step 5 — Read the output (the important part)

Step 6 — Export and integrate

What it costs

Tips, limits & responsible use

Wrap-up

Python: Automate workflows with `apify-client`