# CrazyGames Scraper - Game Ratings, Plays & Details (`abotapi/crazygames-scraper`) Actor

Scrape CrazyGames games with ratings, upvotes and downvotes, total plays and likes, developer, category and tags, descriptions, controls, FAQ, release and update dates, platform support, multiplayer info and store links. Search by keyword, browse categories or the full catalogue, or paste links.

- **URL**: https://apify.com/abotapi/crazygames-scraper.md
- **Developed by:** [Abot API](https://apify.com/abotapi) (community)
- **Features:** Limited permissions
- **Stats:** 8 total users, 3 monthly users, 98.5% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 game records

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## CrazyGames Scraper: Game Ratings, Plays and Details

CrazyGames Scraper turns the CrazyGames catalogue into clean, flat rows: rating on the 0 to 10 scale, upvotes and downvotes, rating count, total plays and total likes, developer, category, tags, full descriptions, controls, FAQ, release and update dates, game engine, platform support, multiplayer lobby sizes, app store links, cover images and preview videos. Search by keyword, browse any category or tag, collect the whole catalogue of thousands of games, or paste links to a game, category, tag, search, new or hot page. Export to JSON, CSV or Excel, or pull the results straight into your app through the API.

### Why This Scraper?

- **Ratings and popularity in one row.** Rating, upvotes, downvotes, rating count, total plays and total likes side by side for every game.
- **Full game profile.** Developer, category, tags, breadcrumb hierarchy, descriptions, controls, FAQ, release date, last update and game engine.
- **Platform and multiplayer coverage.** Mobile, iOS, Android, Chromebook and Safari support, app availability, lobby sizes, moderated chat and instant join.
- **Four ways in.** Keywords, categories or tags, the full catalogue, or pasted game, category, tag, search, new and hot links.
- **Useful filters.** Minimum rating, minimum plays, release year, multiplayer only, mobile-friendly only, Originals only and hot games only.
- **Pay only for what you use.** Switch off full game details when play counts and basic info are enough.
- **Send results to your apps.** Optional export to Notion, Linear, Airtable and more through MCP connectors.

### Use Cases

- **Game discovery sites and app catalogues:** build a searchable listing of browser games with ratings, categories and platform support.
- **Market and trend research:** track how many plays and likes games in a category get, and which developers and engines dominate it.
- **Competitive and portfolio tracking:** watch a developer's catalogue for new releases, updated games and rating changes over time.
- **Recommendation and curation tools:** filter for multiplayer, mobile-friendly or highly rated games to build themed lists.

### Data You Get

> Sample shape: values are illustrative placeholders, not from a live listing.

| Field | Example |
| --- | --- |
| `id` | `"77213099"` |
| `name` | `"Glowmoss Cavern"` |
| `url` | `"https://www.crazygames.com/game/glowmoss-cavern"` |
| `rating` | `8.7` |
| `upvotes` | `15320` |
| `downvotes` | `1180` |
| `ratingCount` | `16500` |
| `totalPlays` | `3200000` |
| `totalLikes` | `15320` |
| `developer` | `"Driftwood Pixel Co"` |
| `category` | `"Puzzle"` |
| `tags` | `[{"name": "Cave", "slug": "cave", "gamesCount": 214}]` |
| `descriptionFirst` | `"Glowmoss Cavern is a lantern-lit puzzle adventure through glowing underground tunnels."` |
| `basicLaunchOn` | `"2023-05-11"` |
| `lastSignificantUpdatedOn` | `"2026-02-03"` |
| `loaderTypeLabel` | `"Unity 2022"` |
| `isMultiplayer` / `maxLobbySize` | `true` / `4` |
| `mobileFriendly` | `true` |
| `coverUrl` | `"https://imgs.crazygames.com/glowmoss-cavern_16x9/cover"` |
| `detailsIncluded` | `true` |

Every record carries 65 fields in total. Beyond the ones above, a game record also holds identifiers and taxonomy (`slug`, `developerId`, `categorySlug`, `hierarchy`, `collection`), the rest of the write-up (`descriptionRest`, `metaDescription`, `controls`, `faq`), release detail (`addedOn`, `releaseYear`, `lastFileUpdatedOn`), engine and platform flags (`loaderType`, `technology`, `orientation`, `status`, `isKids`, `hasIap`, `gameThumbLabels`, `iosFriendly`, `androidFriendly`, `iosAppFriendly`, `androidAppFriendly`, `chromebookFriendly`, `safariFriendly`), the rest of multiplayer (`minLobbySize`, `hasModeratedChat`, `supportsInstantJoin`, `hasLeaderboard`), store and external links (`playStoreUrl`, `appStoreUrl`, `steamStoreUrl`, `msnStoreUrl`, `gameSupportUrl`, `externalLinks`), media (`videoUrl`, `covers`, `previewVideos`, `desktopUrl`), and `allowEmbed`, `gamesInSeries`, `numRelatedGames`, `detailsIncluded` and `scrapedAt`. With **Include full game details** switched off, the rating, vote, developer, description, FAQ, date and store link fields come back empty and `detailsIncluded` is `false`; play counts, category and basic platform flags still come from the listing itself.

### How to Use

1. Pick a mode: **Search** for keywords, categories or the full catalogue, or **URL** for pasted links.
2. Add keywords or categories (or leave both empty to collect every game), set filters and a sort order.
3. Set **Max items** (default 20, 0 for no limit) and start the run.
4. Download the results as JSON, CSV or Excel, or send them to your apps.

**Keyword search with full details:**

```json
{
  "mode": "search",
  "searchTerms": ["car"],
  "maxItems": 20
}
```

**Top rated games in a category:**

```json
{
  "mode": "search",
  "categories": ["action"],
  "minRating": 8.5,
  "maxItems": 50
}
```

**Newest puzzle games, play counts only:**

```json
{
  "mode": "search",
  "categories": ["puzzle"],
  "sortBy": "new",
  "fetchDetails": false,
  "maxItems": 100
}
```

**Pasted links (game and category):**

```json
{
  "mode": "url",
  "urls": [
    "https://www.crazygames.com/game/polytrack",
    "https://www.crazygames.com/c/driving"
  ],
  "maxItems": 50
}
```

##### URL mode link shapes

Running URL mode with the links field untouched now scrapes one example of each shape below (a change from the earlier single category example). Clear the field and paste your own links to limit the run. A link in any other shape is skipped with a warning naming it.

| Link shape | Example |
|---|---|
| Home page (whole catalogue) | `https://www.crazygames.com/` |
| Category | `https://www.crazygames.com/c/action` |
| Tag (may redirect to a category) | `https://www.crazygames.com/t/io` |
| Localized tag | `https://www.crazygames.com/es/t/running` |
| Search | `https://www.crazygames.com/search?q=car` |
| New list | `https://www.crazygames.com/new` |
| Hot list | `https://www.crazygames.com/hot` |
| Updated list | `https://www.crazygames.com/updated` |
| Multiplayer list | `https://www.crazygames.com/multiplayer` |
| Game page | `https://www.crazygames.com/game/getaway-shootout` |
| Localized game page | `https://www.crazygames.com/es/game/getaway-shootout` |
| Category from a page | `https://www.crazygames.com/c/action?page=2` |
| Category sorted newest first | `https://www.crazygames.com/c/action?sort=new` |
| Game link with tracking query | `https://www.crazygames.com/game/getaway-shootout?utm_source=x` |

In search mode, category names may be written as on the site (for example `Action games` or `.io`); a name that matches no category is logged as an error and skipped.

#### Run it from your code

Python:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("abotapi/crazygames-scraper").call(run_input={"mode": "search", "searchTerms": ["car"], "maxItems": 20})
for game in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(game["name"], game["rating"], game["totalPlays"])
```

JavaScript:

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('abotapi/crazygames-scraper').call({ mode: 'search', searchTerms: ['car'], maxItems: 20 });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

Or connect it to Make, Zapier, n8n, Google Sheets or webhooks from the **Integrations** tab.

#### Max items, max pages and multiple sources

**Max items** is the only cap that limits the run; it counts games across every keyword, category or link in the run. When a run has more than one keyword or category, the cap is shared between them, and any share left unused by a source that ran dry is handed to the sources that still have games. **Max pages** is optional and only limits how many listing pages one category, the catalogue or one link walks through; leave it empty or 0 for no page limit, since Max items is what actually stops the run.

#### Pasted game links always come with full details

A pasted link to a single game page (`/game/...`) always fetches and returns that game's full profile (rating, developer, description, dates and platform support), whatever **Include full game details** is set to. That toggle only decides whether category, tag, search, new, hot and catalogue results are enriched with the same detail.

#### Output views and run summary

The dataset has three views, also linked from the run's **Output** tab:

- **Games** (`overview`): rating, votes, plays, developer, category, tags, platform flags and cover, one row per game.
- **Game details** (`detail`): the long-form fields, namely hierarchy, descriptions, controls, FAQ, platform and multiplayer detail, store links and media.
- **Changes since the last run** (`changes`): `changeType`, `changedFields`, `firstSeenAt`, `lastSeenAt` and the key figures, for incremental runs.

A **Run summary** record (`OUTPUT` in the key-value store) lists the mode, how many games were saved, how many came from each keyword, category or link, and, in incremental mode, the `NEW`, `UPDATED`, `UNCHANGED` and `EXPIRED` counts. Unreadable sources are reported in the run log, and a run where no page could be loaded fails instead of reporting an empty result.

### Send results into your apps (MCP connectors)

Optionally pipe each run's games into the tools you already use, via Model Context Protocol (MCP) connectors. This is an extra delivery step after the scrape: the Apify dataset is never changed.

**What gets written to the connector:** a condensed, human-readable summary of each game, not the full JSON record. Each game becomes one entry with a title and its key fields flattened to plain text. The complete record always stays in the Apify dataset.

1. Authorize a connector once under **Apify, Settings, API & Integrations** (Notion, Linear, Airtable or Apify).
2. Select it in the **"Pipe results into your apps"** input field. If the picker is empty, you have not authorized a connector yet.
3. For **Notion**, also set **Notion parent page** to the page where game pages should be created.

Notion receives one page per game. Linear, Airtable and Apify receive a best-effort write through whichever record-creating tool the connector exposes, or a short summary message if no such tool is available. **Max items to export per connector** caps how many games each connector gets per run and never changes the dataset. Leave the connector field empty to skip this step entirely.

### Input Parameters

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| `mode` | string | `search` | `search` for keywords, categories and the full catalogue, or `url` for pasted links only. |
| `searchTerms` | array | prefill: `["car"]` | Game keywords. Search mode only. |
| `categories` | array | (none) | Category or tag names from CrazyGames links, such as `action`, `puzzle`, `io` or `minecraft`. Search mode only. Leave keywords and categories empty to collect every game in the catalogue. |
| `sortBy` | string | `popular` | `popular`, `new` or `updated` (recently updated first), used when browsing categories or the full catalogue. Keyword results always come in best-match order. Search mode only. |
| `minRating` | number | (none) | Keep games rated at least this value on the 0 to 10 scale. Turns on full game details automatically when set. Search mode only. |
| `minTotalPlays` | integer | (none) | Keep games played at least this many times. Search mode only. |
| `minReleaseYear` | integer | (none) | Keep games released in this year or later. Search mode only. |
| `multiplayerOnly` | boolean | `false` | Keep only games with online multiplayer. Search mode only. |
| `mobileFriendlyOnly` | boolean | `false` | Keep only games that play on phones and tablets. Search mode only. |
| `originalsOnly` | boolean | `false` | Keep only games marked as CrazyGames Originals. Search mode only. |
| `hotOnly` | boolean | `false` | Keep only games currently labelled hot. Search mode only. |
| `urls` | array | one example of each link shape in the table above | Game, category, tag, search, multiplayer, new, hot or updated links. Filter fields above are ignored; results continue from the page in the link. |
| `maxItems` | integer | `20` | Maximum games saved across the whole run. `0` means no limit. This is the only cap that limits the run. |
| `maxPages` | integer | (none, unlimited) | Optional page limit per category, catalogue or link. Empty or `0` means unlimited; it does not cap the run, Max items does. |
| `fetchDetails` | boolean | `true` | Adds rating, upvotes and downvotes, developer, tags, descriptions, controls, FAQ, release and update dates, game engine, platform support, store links and related game counts. Turn off for play counts and basic game info only. A pasted single game link always gets full details regardless of this setting. |
| `resumeFromRunId` | string | (none) | Run ID or dataset ID of an earlier run. Games already saved there are skipped: not returned, not charged. |
| `incrementalMode` | boolean | `false` | Recurring monitoring: return only `NEW` and `UPDATED` games after the first run. |
| `stateKey` | string | (none) | Optional name for the saved baseline; by default one is kept per search setup. |
| `emitUnchanged` | boolean | `false` | Also return games that did not change, marked `UNCHANGED`. |
| `emitExpired` | boolean | `true` | Return games that disappeared since the last baseline once as `EXPIRED`, only after a run that read every source to its end. |
| `ignoreFieldsForChanges` | array | (none) | Extra fields that never count as a change, added to the built-in list described in the FAQ. Incremental mode only. |
| `proxy` | object | Apify Proxy | Connection settings. The standard connection is used by default; if it is refused, each page request moves on to a stronger connection and then to a backup connection automatically. |
| `mcpConnectors` | array | (none) | Optional MCP connectors that receive a summary of each game. |
| `notionParentPageUrl` | string | (none) | Notion page that receives one page per game. Notion connector only. |
| `maxNotifyListings` | integer | `50` | Maximum games sent to each connector per run. |

### Output Example

> Sample shape: values are illustrative placeholders, not from a live listing.

```json
{
  "id": "77213099",
  "name": "Glowmoss Cavern",
  "slug": "glowmoss-cavern",
  "url": "https://www.crazygames.com/game/glowmoss-cavern",
  "rating": 8.7,
  "upvotes": 15320,
  "downvotes": 1180,
  "ratingCount": 16500,
  "totalLikes": 15320,
  "totalPlays": 3200000,
  "developer": "Driftwood Pixel Co",
  "developerId": "610044219900",
  "category": "Puzzle",
  "categorySlug": "puzzle",
  "tags": [{ "name": "Cave", "slug": "cave", "gamesCount": 214 }],
  "hierarchy": [{ "name": "Puzzle", "slug": "puzzle", "isCategory": true }],
  "collection": "cave",
  "descriptionFirst": "Glowmoss Cavern is a lantern-lit puzzle adventure through glowing underground tunnels.",
  "descriptionRest": "How to play\nLight your lantern and find every glowmoss node before the cavern goes dark.",
  "metaDescription": "Glowmoss Cavern is a lantern-lit puzzle adventure through glowing underground tunnels.",
  "controls": "Controls\n- Arrow keys to move\n- Space to place a lantern",
  "faq": [{ "question": "Is Glowmoss Cavern free to play?", "answer": "Yes, it plays free in the browser." }],
  "addedOn": "2023-05-12",
  "basicLaunchOn": "2023-05-11",
  "releaseYear": 2023,
  "lastFileUpdatedOn": "2026-02-03",
  "lastSignificantUpdatedOn": "2026-02-03",
  "loaderType": "unity",
  "loaderTypeLabel": "Unity 2022",
  "technology": "iframe",
  "orientation": "LANDSCAPE",
  "status": "PUBLISHED",
  "isKids": false,
  "isOriginal": false,
  "hasIap": false,
  "gameThumbLabels": ["top-rated-desktop"],
  "mobileFriendly": true,
  "iosFriendly": true,
  "androidFriendly": true,
  "iosAppFriendly": false,
  "androidAppFriendly": false,
  "chromebookFriendly": true,
  "safariFriendly": true,
  "isMultiplayer": true,
  "minLobbySize": 2,
  "maxLobbySize": 4,
  "hasModeratedChat": false,
  "supportsInstantJoin": true,
  "hasLeaderboard": true,
  "playStoreUrl": null,
  "appStoreUrl": null,
  "steamStoreUrl": null,
  "msnStoreUrl": null,
  "gameSupportUrl": null,
  "externalLinks": null,
  "videoUrl": null,
  "coverUrl": "https://imgs.crazygames.com/glowmoss-cavern_16x9/cover",
  "covers": { "16x9": "https://imgs.crazygames.com/glowmoss-cavern_16x9/cover" },
  "previewVideos": { "original": "https://videos.crazygames.com/glowmoss-cavern/1/glowmoss-cavern.mp4", "portraitOriginal": null, "landscape": [], "portrait": [] },
  "desktopUrl": "https://games.crazygames.com/en_US/glowmoss-cavern/index.html",
  "allowEmbed": true,
  "gamesInSeries": [],
  "numRelatedGames": 48,
  "detailsIncluded": true,
  "scrapedAt": "2026-02-03T00:00:00+00:00"
}
```

### Plan Requirement

The default proxy setting (Apify Proxy, standard connection) is tried first on every page request, and it was measured serving every page type this actor reads (catalogue lists, category and search pages, game pages and the game data service) on a paid plan, so paid plans need no action. If the site ever refuses a request, that request moves on to the residential connection and then to a backup connection, and the run log says so. Apify free plans do not include any Apify Proxy.

- **Free plans** do not include residential proxies. The run log then shows: "The selected connection is unavailable to this run. Apify free plans do not include residential proxies. Continuing on a backup connection; some pages may still be unavailable." The run continues on the backup connection and states when a page was served over it.
- **Proxy refused for the account:** if no page can be read because the proxy itself is refused, the run ends as failed with: "The proxy connection was refused for this account, so no page could be read. Your Apify plan does not include proxy access; a paid plan is required." Check your own proxy URLs too if you entered any.
- **Residential unavailable and backup also fails:** the run ends as failed with: "No results: residential proxies are unavailable on this run (Apify free plans do not include them), and the backup connection could not load the requested CrazyGames pages."
- **Pages could not be loaded for other reasons:** the run ends as failed with: "Could not load any results page (the requests failed), so nothing was collected. This is a connection problem, not an empty search. Please try again later."

A run that loaded at least one page never fails for connection reasons; sources that could not be read are skipped with a warning. Each page request has a 25 second time budget.

### FAQ

#### How much does it cost?

You pay a small run start fee, plus per game saved to the dataset, plus a small surcharge (the **detail-enrichment** event, one unit per game) for each game whose full details (rating, developer, description, dates and platform support) were read, charged per game right after that game is saved (not as one total at the end of the run), so a run that stops early is billed only for the games already delivered. A pasted single game link always pays that surcharge; in incremental mode, games skipped as unchanged are neither saved nor charged; category, tag, search and catalogue results only pay it while **Include full game details** is on, which is its default setting. The **Pricing** tab shows the current rates. In incremental mode each `EXPIRED` row (a game that disappeared since the last baseline, returned once) is a saved row and is charged like any other saved game; it never carries the detail-enrichment surcharge. Switch off **Emit expired games** to skip them. A game whose details could not be read in an incremental run keeps its previous saved details and counts as `UNCHANGED`: it is skipped (not saved, not charged) unless **Emit unchanged games** is on, in which case its previously saved details are returned as an `UNCHANGED` row, charged like any saved game and never with the detail-enrichment surcharge. Use **Max items** to cap the cost of any run.

#### Is it legal to scrape CrazyGames?

This actor collects only publicly available game listing data. You are responsible for how you use it: follow CrazyGames' terms and the laws that apply to you, and get legal advice if you plan commercial redistribution. Cover images, preview videos and game descriptions may be subject to third-party rights.

#### Can I schedule this to catch new or updated games?

Yes. Switch on **Incremental changes for scheduled runs** in the **🔁 Resume & recurring updates** section, then add a schedule from the **Schedules** tab. The first run returns every matching game as `NEW`. Later runs return only `NEW` and `UPDATED` games, each with `changeType`, `changedFields`, `firstSeenAt` and `lastSeenAt`; games that did not change are skipped, not saved and not charged. Turn on **Emit unchanged games** to get them as `UNCHANGED` rows. When a run reads every selected source to its end, games that disappeared since the last baseline come back once as `EXPIRED` rows (switch off with **Emit expired games**); capped, paged-from-N or failed runs never expire anything.

Change detection ignores the numbers that move on every run, so a busy game does not show up as updated every day: `totalPlays`, `totalLikes`, `upvotes`, `downvotes`, `ratingCount`, `rating`, `scrapedAt` and the play and like counts inside `gamesInSeries`. They are still returned on every row you receive. Add your own with **Ignore fields when detecting changes (incremental mode only)** (nested paths such as `gamesInSeries.releaseYear` work). The saved baseline is kept per search setup (mode, keywords, categories, links, filters, sort order and the full-details setting); **State key** lets you name or share one. Max items counts only the games returned. Without incremental mode every run is independent and returns the full result for its inputs.

#### Why did category or catalogue browsing return fewer games than I expected?

Check **Max items** first; it is the only cap that limits the run, and it is shared across every keyword, category or link you gave it. **Max pages**, if set, stops a single category, the catalogue or a link after that many listing pages regardless of Max items. Filters such as minimum rating or multiplayer only also narrow the result after the listing is read.

#### Why did my run finish with an empty dataset?

If a keyword, category or link cannot be read even after every retry and connection switch, that source is skipped with a warning in the run log and the other sources continue. If pages loaded but none of your keywords, categories or links returned a game, the dataset is empty and the run status notes that no games matched. If no page at all could be loaded, the run fails with a connection message (see Plan Requirement) instead of reporting an empty result. Check the log for which source could not be read, then adjust the input or run it again.

#### Can I use it with AI agents or MCP?

Yes. Call it from any Apify integration or MCP client, and use the connector field to push results into Notion, Linear or Airtable.

### 🔗 More scrapers you might like

Pair this actor with these related scrapers from the same team:

<table>
<tr><td>🛒 <a href="https://apify.com/abotapi/itch-io-scraper"><b>itch.io Game, Review, Creator and Jam Scraper</b></a><br>Scrape itch.io games by genre, tag, platform, price band or keyword, plus creator...</td><td>🧩 <a href="https://apify.com/abotapi/ok-ru-scraper"><b>OK.ru Scraper</b></a><br>Scrape public OK.ru users, groups, topics, posts, videos, games and greetings by keyword...</td></tr>
<tr><td>🎬 <a href="https://apify.com/abotapi/twitch-scraper"><b>Twitch Scraper</b></a><br>Scrape Twitch data at scale, including channels, live streams, clips, VODs, and top...</td><td>🧩 <a href="https://apify.com/abotapi/roblox-scraper"><b>Roblox Scraper</b></a><br>Scrape Roblox experiences, marketplace items, users and communities. Player counts...</td></tr>
<tr><td>🧩 <a href="https://apify.com/abotapi/pinedrama-scraper"><b>PineDrama Scraper</b></a><br>Scrape Pine Drama series by keyword, category or URL across 17 languages. Extract titles...</td><td>📱 <a href="https://apify.com/abotapi/google-play-reviews-scraper"><b>Google Play Reviews</b></a><br>Collect Google Play reviews and ratings for any app across country storefronts. Search by...</td></tr>
</table>

👉 [Browse all abotapi scrapers](https://apify.com/abotapi)

### 💬 Support

- 🐞 **Found a bug or a missing field?** Open a ticket on the [Issues tab](https://apify.com/abotapi/crazygames-scraper/issues/open). We usually reply within hours.
- 🛠️ **Need another site, extra fields or a private build?** Email <contact@abotapi.com>.
- ⭐ **Enjoying it?** A quick review on the actor page helps other users find it.

</content>

# Actor input Schema

## `mode` (type: `string`):

Search mode uses keywords, categories, filters and sorting (leave keywords and categories empty to collect the full game catalogue). URL mode uses only the pasted links and ignores every search input.

## `searchTerms` (type: `array`):

Game keywords, such as car or minecraft. Each keyword returns the best matching games. Search mode only.

## `categories` (type: `array`):

Category or tag names as shown in CrazyGames links, such as action, puzzle, io, shooting, driving, 2-player or minecraft. Search mode only. Leave keywords and categories empty to collect every game in the catalogue.

## `sortBy` (type: `string`):

Order used when browsing categories or the full catalogue. Keyword results always come in best-match order. Search mode only.

## `minRating` (type: `number`):

Keep games rated at least this value on the 0 to 10 scale. Needs full game details, which are switched on automatically when this is set. Search mode only.

## `minTotalPlays` (type: `integer`):

Keep games played at least this many times. Search mode only.

## `minReleaseYear` (type: `integer`):

Keep games released in this year or later. Search mode only.

## `multiplayerOnly` (type: `boolean`):

Keep only games with online multiplayer. Search mode only.

## `mobileFriendlyOnly` (type: `boolean`):

Keep only games that play on phones and tablets. Search mode only.

## `originalsOnly` (type: `boolean`):

Keep only games marked as CrazyGames Originals. Search mode only.

## `hotOnly` (type: `boolean`):

Keep only games currently labelled hot. Search mode only.

## `urls` (type: `array`):

Multi-URL: game pages (/game/...), category pages (/c/...), tag pages (/t/...), search pages (/search?q=...), the home page, and the /new, /hot, /updated and /multiplayer lists. Filter fields are ignored; results continue from the page in the link (?page=N) and ?sort=new is honoured on category links. Links in other site languages work too. Left untouched, URL mode scrapes one example of each shape.

## `maxItems` (type: `integer`):

Maximum games to save across all searches and links. This is the only default cap. Set 0 for no limit.

## `maxPages` (type: `integer`):

Optional page limit per category, catalogue or link. Leave empty or 0 for unlimited: this does NOT cap the run, Max items does.

## `fetchDetails` (type: `boolean`):

Adds rating, upvotes and downvotes, rating count, developer, tags, descriptions, controls, FAQ, release and update dates, game engine, platform support, store links and related game counts. Turn off for play counts and basic game info only.

## `proxy` (type: `object`):

Apify Proxy settings. The default Apify Proxy setting is the cheapest and suits most runs. If the site refuses requests the run moves to another connection automatically and returns to the cheaper one when possible. Free-plan accounts do not include residential proxy; the run continues without it.

## `resumeFromRunId` (type: `string`):

Paste a previous run ID or dataset ID to continue an interrupted pull. Games already saved there are skipped: they are not returned and not charged again. For recurring monitoring of the same search, use Incremental changes below instead. Leave empty for a normal run.

## `incrementalMode` (type: `boolean`):

Turn this on for daily or recurring monitoring. The first run returns every matching game as NEW. Later runs return only NEW and UPDATED games, each with changeType, changedFields, firstSeenAt and lastSeenAt. A game counts as UPDATED when a real field changes (name, tags, description, release or update dates, platform support, labels and similar). Play counts, likes, votes, rating, rating count and the scrape time never count as changes, though they are still returned; add more below. The saved baseline is kept separately for each mode, keywords, categories, links, filters, sort order and details setting; use State key to name or share one. Max items counts only the games returned.

## `stateKey` (type: `string`):

Name of the saved baseline. Leave empty to keep one automatically per search setup. Use the same key to share a baseline between runs on purpose.

## `emitUnchanged` (type: `boolean`):

Off by default. Turn on to also return games that did not change, marked UNCHANGED. They are saved to the dataset like any other row, but never carry the game details surcharge.

## `emitExpired` (type: `boolean`):

On by default. When a run reads every selected source to its end (no Max items or Max pages cut, no link starting past page 1, no read failures), games saved in the baseline but no longer listed come back once as EXPIRED. Games that were not seen because a run stopped early are never marked expired.

## `ignoreFieldsForChanges` (type: `array`):

Extra field names that must not make a game count as UPDATED, added to the built-in list (totalPlays, totalLikes, upvotes, downvotes, ratingCount, rating, scrapedAt). Ignored fields are still returned. Nested paths such as gamesInSeries.releaseYear also work.

## `mcpConnectors` (type: `array`):

Optionally send results into the apps you already use, via Model Context Protocol (MCP) connectors. Authorize one under Apify, Settings, API & Integrations, then select it here. Notion gets a page per game; other connectors get a best-effort write or digest. Each connector receives a condensed summary per game, not the full record; the complete record always stays in the dataset. Leave empty to skip; this never changes the dataset output. Supported: Notion (https://mcp.notion.com/mcp), Linear (https://mcp.linear.app/sse), Airtable (https://mcp.airtable.com/mcp), Apify (https://mcp.apify.com).

## `notionParentPageUrl` (type: `string`):

URL or id of the Notion page under which game pages are created. Required to enable the Notion export; ignored by other connectors.

## `maxNotifyListings` (type: `integer`):

Cap on games written to each connector per run. Does not affect the dataset.

## Actor input object example

```json
{
  "mode": "search",
  "searchTerms": [
    "car"
  ],
  "sortBy": "popular",
  "multiplayerOnly": false,
  "mobileFriendlyOnly": false,
  "originalsOnly": false,
  "hotOnly": false,
  "urls": [
    "https://www.crazygames.com/",
    "https://www.crazygames.com/c/action",
    "https://www.crazygames.com/t/io",
    "https://www.crazygames.com/search?q=car",
    "https://www.crazygames.com/new",
    "https://www.crazygames.com/hot",
    "https://www.crazygames.com/updated",
    "https://www.crazygames.com/multiplayer",
    "https://www.crazygames.com/game/getaway-shootout",
    "https://www.crazygames.com/c/action?page=2"
  ],
  "maxItems": 20,
  "fetchDetails": true,
  "proxy": {
    "useApifyProxy": true
  },
  "incrementalMode": false,
  "emitUnchanged": false,
  "emitExpired": true,
  "maxNotifyListings": 50
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

## `detail` (type: `string`):

No description

## `changes` (type: `string`):

No description

## `runSummary` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "mode": "search",
    "searchTerms": [
        "car"
    ],
    "urls": [
        "https://www.crazygames.com/",
        "https://www.crazygames.com/c/action",
        "https://www.crazygames.com/t/io",
        "https://www.crazygames.com/search?q=car",
        "https://www.crazygames.com/new",
        "https://www.crazygames.com/hot",
        "https://www.crazygames.com/updated",
        "https://www.crazygames.com/multiplayer",
        "https://www.crazygames.com/game/getaway-shootout",
        "https://www.crazygames.com/c/action?page=2"
    ],
    "maxItems": 20,
    "proxy": {
        "useApifyProxy": true
    },
    "incrementalMode": false,
    "emitUnchanged": false,
    "emitExpired": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("abotapi/crazygames-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "mode": "search",
    "searchTerms": ["car"],
    "urls": [
        "https://www.crazygames.com/",
        "https://www.crazygames.com/c/action",
        "https://www.crazygames.com/t/io",
        "https://www.crazygames.com/search?q=car",
        "https://www.crazygames.com/new",
        "https://www.crazygames.com/hot",
        "https://www.crazygames.com/updated",
        "https://www.crazygames.com/multiplayer",
        "https://www.crazygames.com/game/getaway-shootout",
        "https://www.crazygames.com/c/action?page=2",
    ],
    "maxItems": 20,
    "proxy": { "useApifyProxy": True },
    "incrementalMode": False,
    "emitUnchanged": False,
    "emitExpired": True,
}

# Run the Actor and wait for it to finish
run = client.actor("abotapi/crazygames-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "mode": "search",
  "searchTerms": [
    "car"
  ],
  "urls": [
    "https://www.crazygames.com/",
    "https://www.crazygames.com/c/action",
    "https://www.crazygames.com/t/io",
    "https://www.crazygames.com/search?q=car",
    "https://www.crazygames.com/new",
    "https://www.crazygames.com/hot",
    "https://www.crazygames.com/updated",
    "https://www.crazygames.com/multiplayer",
    "https://www.crazygames.com/game/getaway-shootout",
    "https://www.crazygames.com/c/action?page=2"
  ],
  "maxItems": 20,
  "proxy": {
    "useApifyProxy": true
  },
  "incrementalMode": false,
  "emitUnchanged": false,
  "emitExpired": true
}' |
apify call abotapi/crazygames-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,abotapi/crazygames-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/7IT0mYaFrz0sfEAIm/builds/NxZvFasYPARvEHJZe/openapi.json