Video Game Database Scraper: 16 Data Fields per Record (2026)

Each output record carries 16 fields, providing structured metadata for developer, publisher, platform, genre, and initial release year without requiring a Wikidata API key. This data is pulled directly from a crowdsourced catalog of over 500,000 games. A thousand results cost $5.00 on the free-plan price, and you can test-drive the extractor with smaller caps on Apify's free plan. This scraper is ideal for builders creating gaming wikis, historical archives, or catalog apps; it is not suitable for those who require live commercial pricing data, direct retail store links, or user reviews.

Try it: open Video Game Database Scraper on Apify, sign in on the free plan and run the prefilled example.

Can you try Video Game Database Scraper before paying?

Yes. Apify's free plan includes $5.00 of prepaid usage every month and asks for no credit card. At $0.005 per result, that covers up to 1,000 results of Video Game Database Scraper a month, before run-start charges and platform usage.

The example request further down caps maxItems at 20, so a first run returns at most 20 results and costs at most $0.10 in result charges. That is enough to see the real shape of the data before deciding anything.

Video Game Database Scraper was last updated on 2026-05-27. It is one of 1,724 Actors CrawlerBros publishes on Apify, which together have 728,502 lifetime public runs and an average rating of 4.63 out of 5 across 416 reviews.

What does it cost to run Video Game Database Scraper?

Each result costs $0.005 on Apify's free plan, which is $5.00 per 1,000 results. Starting a run is charged separately at $0.005 per GB of Actor memory. Apify also bills the platform usage each run consumes, at the rates of your Apify plan, on top of these charges.

The maxItems input control has the most immediate impact on your bill because it directly limits how many dataset records are written and charged. To test your setup without wasting budget, keep the default maxItems at 20 on your first run. This keeps the result-based portion of your run cost capped at just $0.10 while letting you inspect the full structure of the output fields.

How do you run Video Game Database Scraper from the API?

The schema marks 1 of its 9 controls as required: mode. The payload below uses the schema's own prefilled values, so it runs as written once you substitute your API token.

Call the synchronous endpoint to start a run and receive dataset items in one request:

curl -X POST "https://api.apify.com/v2/acts/crawlerbros~mobygames-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mode":"searchGames","query":"mario","maxItems":20}'

The same run from Python, using the official client:

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run_input = {
  "mode": "searchGames",
  "query": "mario",
  "maxItems": 20
}

run = client.actor("crawlerbros~mobygames-scraper").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

And from Node.js:

import { ApifyClient } from 'apify-client'

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' })

const input = {
  "mode": "searchGames",
  "query": "mario",
  "maxItems": 20
}

const run = await client.actor('crawlerbros~mobygames-scraper').call(input)
const { items } = await client.dataset(run.defaultDatasetId).listItems()
console.log(items)

The synchronous endpoint holds the connection open until the run finishes, which is convenient for small batches and wrong for large ones. For anything long running, start the run asynchronously and poll, or attach a webhook, so a dropped connection does not cost you the results.

Which Video Game Database Scraper inputs matter, and which can you skip?

The mode parameter is the essential control that defines where the scraper looks, allowing you to switch between broad searches and precise profile lookups. Use platform and genre to restrict your search queries; leaving these blank is best on your initial run to avoid over-filtering.

• mode (string): Select what to scrape. Default: "searchGames".
• query (string): Game title to search for. Used in searchGames mode. Examples: 'mario', 'zelda', 'final fantasy'. Default: "mario".
• wikidataId (string): Wikidata Q-identifier for a specific game (e.g. Q1075592 for Super Mario Bros.). Used in gameDetails mode.
• gameUrl (string): Full Wikidata URL for a specific game, e.g. https://www.wikidata.org/wiki/Q1075592. Used in gameDetails mode when wikidataId is not provided.
• platform (string): Filter results by gaming platform. Used in searchGames, byPlatform, and recentReleases modes.
• genre (string): Filter results by game genre. Used in searchGames and recentReleases modes.
• fromYear (integer): Only include games released from this year onwards.
• toYear (integer): Only include games released up to and including this year.
• maxItems (integer): Maximum number of game records to emit. Default: 20.

Fixed-choice controls: mode accepts searchGames (Search Games by title), gameDetails (full metadata for a specific game), byPlatform (Browse Games by Platform), recentReleases (latest games added to Wikidata); platform accepts 25 values, including Windows (Windows PC), PlayStation 4, PlayStation 5, Xbox One; genre accepts 13 values, including action game (Action), adventure game (Adventure), role-playing video game (Role-Playing (RPG)), strategy video game (Strategy).

What does Video Game Database Scraper return?

The returned records are excellent for building reference databases and mapping relationships between developers and platforms. However, they do not contain real-time market pricing, review scores, or active store listings. If you need commercial values, you will need to map these Wikidata identifiers to other retail-focused APIs.

• recordType: string - Always "game"
• wikidataId: string - Wikidata Q-identifier (e.g. Q1075592)
• wikidataUrl: string - Direct link to the Wikidata game page
• title: string - Game title
• description: string - Short editorial description
• releaseYear: integer - Year of initial release
• developer: string - Primary developer
• developers: array - All known developers
• publisher: string - Primary publisher
• publishers: array - All known publishers
• platforms: array - Platforms the game was released on
• initialPlatform: string - First listed platform
• genres: array - Game genres (e.g. ["platform game", "action game"])
• officialWebsite: string - Official game website URL
• coverImageUrl: string - Cover or promotional image URL
• scrapedAt: string - ISO timestamp of scrape

These are the documented fields. Optional ones can be empty on a given record, so measure how often each field your deliverable depends on is populated across a real sample before automating the handoff.

How do you build the workflow end to end?

Open Video Game Database Scraper and work through these in order. Each step ends with something to check, so a bad configuration surfaces on a small run rather than a scheduled one.

1. Select the required mode based on your target dataset; choose searchGames for text matching, byPlatform to pull everything for a console, or recentReleases to track new additions.
2. Set the query parameter when using searchGames mode to specify your target keyword, keeping it broad at first to inspect the results.
3. Add filters such as platform and genre using their exact enum values like Nintendo Switch or action-adventure game to focus the returned records.
4. Define a temporal range using fromYear and toYear to isolate retro titles or modern releases within a specific gaming era.
5. Restrict the initial output size by setting maxItems to 20 to verify the structure and content of your dataset without consuming excess credits.
6. Initiate the run and navigate to the Apify dataset tab once the scrape completes to review the output structures.
7. Verify that key output fields like wikidataId, title, and releaseYear are fully populated and structured correctly before scaling up.

How do you apply it? Three worked playbooks

These are Video Game Database Scraper's own documented use cases, each worked through as an operating pattern rather than a description.

Use case 1: Game databases

Outcome: Build or enrich video game catalogues with comprehensive metadata

Configure: Set mode to searchGames, set query to "zelda", set platform to "Nintendo Switch", and set maxItems to 50.

Working method: Run the initial query targeting a well-documented franchise to verify field completeness. Export the results to JSON and inspect the nested developers and genres arrays. Map these values into your local database schema, then scale up your queries to cover your entire backlog list.

Deliverable: A structured JSON or CSV file containing fully populated game profiles with active wikidataUrl and officialWebsite links.

Stop condition: The dataset returns objects with null title values or missing wikidataId fields.

Use case 2: Gaming journalism

Outcome: Research game histories, developer portfolios, and platform catalogs

Configure: Set mode to byPlatform, set platform to "Sega Genesis", set fromYear to 1989, set toYear to 1995, and set maxItems to 100.

Working method: Execute the scrape to extract the platform's historical catalog during its active commercial lifespan. Sort the output locally by releaseYear to construct a historical timeline of releases. Cross-reference the developer and publisher fields to identify the most prolific creators on that hardware.

Deliverable: A comprehensive spreadsheet cataloging historical software releases for a chosen console, detailed by release year and original developer.

Stop condition: The returned releaseYear values systematically violate the specified fromYear and toYear boundaries.

Use case 3: Academic research

Outcome: Study game industry trends and platform histories

Configure: Set mode to recentReleases and set maxItems to 500.

Working method: Run the Actor periodically to capture the latest crowdsourced metadata changes added to Wikidata. Group the output dataset by genre and releaseYear to analyze which game categories are seeing the most documentation activity. Count the platform variety per game to measure modern cross-platform trends.

Deliverable: A statistical report outlining metadata entry trends, genre distribution, and multi-platform publishing patterns.

Stop condition: The recordType field deviates from the expected constant value of "game".

What breaks, and how do you design around it?

Because this scraper relies on Wikidata's public query service, extremely broad queries can occasionally hit response size limits. To circumvent this, split your requests into narrower ranges using the fromYear and toYear filters. If you hit a limit, reduce your maxItems parameter and run multiple targeted queries instead of one massive dump.

When should you not use Video Game Database Scraper?

Do not use this scraper if your objective is to monitor current market pricing, track discounts, or analyze commercial availability across major storefronts. Wikidata's open-source database does not maintain real-time retail pricing. Instead, you should extract that transactional data directly from source-specific platforms. If you are targeting digital storefronts, use the GOG.com Game Scraper or the Epic Games Store Scraper. If you need secondary market values, historical valuation guides, and physical cartridge prices, use the PriceCharting Video Game Price Scraper. For tracking critic reception and review averages, use the OpenCritic Game Reviews & Scores Scraper.

What should you check before trusting the output?

• Check that the wikidataId field matches the standard regex pattern ^Q\d+$ to ensure downstream system compatibility.
• Monitor the presence of the developers and publishers arrays, noting that less-documented games may fall back to the single string developer or publisher fields.
• Set a validation rule to flag records where releaseYear is null or falls outside the expected range of 1950 to 2030.
• Create an alert if the platforms array is empty, which indicates an incomplete metadata profile on the Wikidata side.
• Expect that coverImageUrl will be occasionally missing or null, as it depends on user uploads to Wikimedia Commons, and configure your ingestion pipeline to handle this fallback.

None of this proves a record is correct. It gives a scheduled Video Game Database Scraper run defined points where it should stop instead of quietly passing bad data downstream.

Frequently asked questions

How much does it cost to run this scraper on a larger database?

At the free-plan price, extracting 1,000 game records will cost $5.00 in result charges. If you scale up your research to 10,000 games, the result costs will total $50.00. Keep in mind that Apify also bills for the platform usage and RAM consumed during the run on top of these result charges.

Can I search for games on a specific platform without typing a query?

Yes. You can switch the mode parameter to byPlatform and leave the search query empty. This configuration allows you to systematically browse and download the entire catalog for platforms like the Nintendo Switch or Sega Genesis.

Why are some cover images or descriptions missing from the dataset?

All extracted metadata is sourced directly from Wikidata. Because Wikidata is a crowdsourced knowledge base, less popular or obscure indie games might not have an editorial description or an uploaded image on Wikimedia Commons yet.

Do I need to sign up for a Wikidata API key to use this?

No API key or registration is required. The scraper queries the public Wikidata SPARQL interface directly, bypassing the need for developers to manage credentials or register external developer accounts.

How can I look up a single, specific game if I already know its ID?

Set the mode control to gameDetails and input the Q-identifier into the wikidataId field. For example, using Q1075592 will directly return the structured metadata profile for Super Mario Bros.

Where to go next

When you are ready to run it, open Video Game Database Scraper on Apify; the free plan covers up to 1,000 results a month.

Start with the Video Game Database Scraper Actor page for the current input schema, pricing tier, and run history.

If you are comparing approaches rather than committing to one Actor, these category pages list every option we publish:

• Video and transcript scrapers covers 48 Actors in this family.

Other Actors we maintain for related data:

• Loaded (CDKeys) Game Key Store Scraper: Scrape Loaded.com (formerly CDKeys.com) - search game keys, browse by platform (PC/PlayStation/Xbox/Nintendo), deals, new releases, gift cards and franchises.
• GOG.com Game Scraper: Scrape GOG.com game catalog with search by title, browse by genre, or fetch specific games by ID.
• OpenCritic Game Reviews & Scores Scraper: Scrape OpenCritic browse lists and game pages.
• Nintendo eShop Scraper: Scrape the Nintendo eShop - search for games by title, browse by platform/genre, or look up games by ID.
• PriceCharting Video Game Price Scraper: Scrape PriceCharting.com - the authoritative video game price guide.
• Kinguin Game Key Marketplace Scraper: Scrape Kinguin.net game key marketplace.
• Epic Games Store Scraper: Scrape the Epic Games Store with current and upcoming free games, catalog search, and featured games.

Related guides:

• TapTap Scraper: 3 Practical Use Cases
• Replicate AI Model Explore Scraper: 19 Data Fields per Record (2026)
• TikTok Explore/Trending Scraper: 26 Data Fields per Record (2026)
• YouTube Video Downloader: 24 Data Fields, Up to 500 Free Results/Month

Resources

• Actor documentation, input schema, and pricing: verified against the published Actor on 2026-10-03.

• Actor last updated by its maintainers on 2026-05-27.

• Run outcome figures cover the 30 day public window ending 2026-10-03.

• Video Game Database Scraper on Apify