# CheapShark Game Deals Scraper (`automation-lab/cheapshark-pc-game-deals`) Actor

Search current CheapShark PC game deals across stores and export IDs, regular and sale prices, savings, ratings, timestamps, thumbnails, and deal links.

- **URL**: https://apify.com/automation-lab/cheapshark-pc-game-deals.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Games
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.65 / 1,000 item extracteds

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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## CheapShark Game Deals Scraper

Export **CheapShark game deals** as clean, monitoring-ready records.
Search by game title or browse the current cross-store feed, filter it, and save
stable game IDs, deal IDs, store names, regular prices, sale prices, savings,
ratings, timestamps, thumbnails, and clickable deal links.

The Actor uses CheapShark's anonymous public JSON interface.
It does not need a CheapShark account, API key, browser, or proxy.
Results are written to the run's default dataset for JSON, CSV, Excel, API,
and integration use.

### What can you do with this Actor?

- Search current offers for one or more PC game titles.
- Build a current deal feed for selected CheapShark stores.
- Filter by sale price, savings, Metacritic score, or Steam rating.
- Schedule recurring snapshots for price-change monitoring.
- Feed current prices into spreadsheets, dashboards, alerts, or databases.
- Keep stable source identifiers and timestamps for downstream comparisons.

This Actor returns current source records.
It does not calculate historical price changes or send alerts by itself.
Use scheduled runs and compare datasets in your own workflow when history is
needed.

### Who is it for?

**Deal publishers** can assemble a filtered feed with links and images.

**Game publishers and studios** can monitor cross-store discount positioning.

**Pricing analysts** can compare sale price, regular price, and savings across
CheapShark-tracked storefronts.

**Developers and data teams** can consume a stable normalized schema instead of
maintaining API pagination, store lookup, retries, and data conversion.

**Researchers** can create timestamped snapshots for analysis while respecting
CheapShark's terms and rate limits.

### Why use this CheapShark exporter?

CheapShark exposes useful structured data, but production exports still need
input validation, pagination, stable deduplication, store-name resolution,
timestamp conversion, and dataset delivery.
This Actor packages those steps into a schedule-ready Apify workflow.

The implementation is deliberately lightweight:

- direct JSON requests instead of browser rendering;
- a descriptive client User-Agent as required by CheapShark;
- bounded retries only for transient network, rate-limit, and server failures;
- no automatic residential-proxy fallback;
- one store metadata request per run;
- deduplication by stable CheapShark deal ID;
- a hard maximum of 1,000 saved deals per run.

### What data is extracted?

| Field | Meaning |
| --- | --- |
| `gameId` | Stable CheapShark game identifier |
| `dealId` | CheapShark deal identifier |
| `title` | Displayed game title |
| `internalName` | CheapShark normalized internal title |
| `storeId` | CheapShark storefront identifier |
| `storeName` | Resolved storefront name |
| `salePrice` | Current sale price in USD |
| `regularPrice` | Regular retail price in USD |
| `currency` | `USD` for CheapShark price fields |
| `savingsPercent` | Percentage saved from regular price |
| `isOnSale` | Whether the offer is marked as on sale |
| `dealRating` | CheapShark deal quality rating |
| `metacriticScore` | Metacritic score when exposed |
| `metacriticUrl` | Metacritic game link when exposed |
| `steamAppId` | Steam app ID when exposed |
| `steamRatingText` | Steam review sentiment label |
| `steamRatingPercent` | Positive Steam review percentage |
| `steamRatingCount` | Steam review count exposed by CheapShark |
| `releaseDate` | ISO 8601 game release timestamp |
| `lastChangeAt` | ISO 8601 timestamp of the latest deal change |
| `thumbnailUrl` | Game thumbnail URL |
| `dealUrl` | Clickable CheapShark storefront redirect |
| `sourceApiUrl` | Exact API page used for the record |
| `searchQuery` | Title search that produced the record, or `null` |
| `scrapedAt` | ISO 8601 collection timestamp |

Source fields can be absent for individual games.
The dataset schema therefore treats fields as nullable even when normal deal
rows usually contain them.

### Getting started

1. Open the Actor in Apify Console.
2. Add one or more game titles, or leave the title list empty for the deal feed.
3. Optionally enter CheapShark store IDs and price or rating filters.
4. Choose the maximum number of unique deals.
5. Click **Start**.
6. Open **Dataset** to preview, download, or integrate the records.
7. Add an Apify schedule if you need recurring snapshots.

A small first run is recommended before raising `maxItems`.

### Input parameters

#### `searchQueries`

Optional array of up to 20 game-title searches.
Each value may contain at most 100 characters.
Leave the array empty to browse the current deal feed.
Records are deduplicated when several searches return the same deal.

#### `storeIds`

Optional numeric CheapShark storefront IDs.
For example, `1` is Steam and `7` is GOG at the time of writing.
The Actor resolves IDs through the current CheapShark stores endpoint and
rejects unknown IDs instead of silently returning misleading output.

#### Price and discount filters

- `minPrice`: minimum sale price in USD.
- `maxPrice`: maximum sale price in USD.
- `minimumSavings`: minimum percentage saved, from 0 to 100.
- `onlyOnSale`: limit results to active sales; defaults to `true`.

#### Rating filters

- `minimumMetacriticScore`: minimum score from 0 to 100.
- `minimumSteamRating`: minimum positive Steam rating percentage from 0 to 100.

Ratings are source-provided.
Games without the required rating do not satisfy a rating filter.

#### Ordering and limit

`sortBy` supports deal rating, title, savings, price, Metacritic, Steam reviews,
release date, store, and recent changes.
Use `descending` to reverse the selected source order.
`maxItems` accepts 1 to 1,000 and applies across every search and page.

### Example inputs

Search two game families:

```json
{
  "searchQueries": ["Civilization", "Batman"],
  "onlyOnSale": true,
  "maxItems": 20
}
```

Export current Steam and GOG offers below $30:

```json
{
  "storeIds": ["1", "7"],
  "maxPrice": 30,
  "onlyOnSale": true,
  "maxItems": 25
}
```

Create a high-savings monitoring feed:

```json
{
  "minimumSavings": 70,
  "minimumSteamRating": 75,
  "sortBy": "recent",
  "descending": true,
  "onlyOnSale": true,
  "maxItems": 30
}
```

### Output example

A current local run produced a normalized record shaped like this:

```json
{
  "gameId": "152578",
  "dealId": "sampleDealId%3D",
  "title": "Sid Meiers Civilization VI",
  "internalName": "SIDMEIERSCIVILIZATIONVI",
  "storeId": "3",
  "storeName": "GreenManGaming",
  "salePrice": 5.4,
  "regularPrice": 59.99,
  "currency": "USD",
  "savingsPercent": 90.9985,
  "isOnSale": true,
  "dealRating": 9.4,
  "metacriticScore": 88,
  "steamAppId": "289070",
  "steamRatingText": "Very Positive",
  "steamRatingPercent": 85,
  "steamRatingCount": 107476,
  "lastChangeAt": "2026-09-04T12:00:00.000Z",
  "thumbnailUrl": "https://shared.fastly.steamstatic.com/store_item_assets/steam/apps/289070/capsule_231x87.jpg",
  "dealUrl": "https://www.cheapshark.com/redirect?dealID=sampleDealId%253D",
  "searchQuery": "Civilization",
  "scrapedAt": "2026-09-07T20:10:00.000Z"
}
```

The example deal ID and timestamps are anonymized.
Actual runs preserve source values.

### How much does it cost to export CheapShark game deals?

This Actor uses pay-per-event pricing:

- one small `start` event per run;
- one `item` event for each normalized deal saved to the dataset.

The per-item event is the primary charge.
Filtered-out, duplicate, incomplete, or failed records are not charged as
items.

| Apify tier | Price per saved deal |
| --- | ---: |
| Free | $0.001242 |
| Bronze | $0.00108 |
| Silver | $0.0008424 |
| Gold, Platinum, Diamond | $0.000648 |

The start fee is $0.0015 per run.
At Bronze pricing, 10 saved deals cost about $0.0123 and 100 saved deals cost
about $0.1095, including one start event.
Apify shows the exact applicable tier before a run starts.
Infrastructure usage is handled according to the pricing shown in Console.

### Recurring price monitoring workflow

1. Choose a stable title list, storefront list, or filter set.
2. Run once and store the dataset ID and `scrapedAt` timestamp.
3. Schedule the same Actor input daily or weekly.
4. Join snapshots by `dealId`, or by `gameId` plus `storeId`.
5. Compare `salePrice`, `regularPrice`, `savingsPercent`, and `lastChangeAt`.
6. Trigger your own notification only when the change meets your threshold.

A deal ID identifies a source deal, while game and store IDs are useful for
longer-lived joins when deal IDs change.

### Spreadsheet and database exports

Open the run dataset and select JSON, CSV, Excel, XML, or another supported
Apify export format.
For Google Sheets, databases, and BI tools, connect the dataset API or use an
Apify integration after each scheduled run.

Keep numeric price fields as numbers.
Use `currency` explicitly in downstream tables even though the current source
contract is USD.

### API usage with cURL

Start a run and wait for its dataset:

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~cheapshark-pc-game-deals/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"searchQueries":["Civilization"],"onlyOnSale":true,"maxItems":10}'
```

Keep tokens in environment variables or a secret manager.
Do not commit them to source code.

### API usage with JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/cheapshark-pc-game-deals').call({
  storeIds: ['1', '7'],
  maxPrice: 30,
  maxItems: 25,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/cheapshark-pc-game-deals').call(run_input={
    'minimumSavings': 70,
    'minimumSteamRating': 75,
    'maxItems': 30,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### Use through MCP

Add the Apify MCP server to Claude Code:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/cheapshark-pc-game-deals"
```

Equivalent configuration for **Claude Desktop**, **Cursor**, and **VS Code**:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/cheapshark-pc-game-deals"
    }
  }
}
```

In Claude Desktop, Cursor, or VS Code, add this JSON to the client's MCP server configuration, restart the client, and select the `automation-lab/cheapshark-pc-game-deals` tool.

Example prompts:

- “Search CheapShark for current Civilization deals and return 20 rows.”
- “Export Steam and GOG sales below $20 into a table.”
- “Run my 70%-savings game-deal snapshot and summarize changed timestamps.”

### Reliability and retry behavior

Each API request has a 30-second timeout.
The Actor retries network errors, HTTP 429, and temporary HTTP 5xx responses at
most three times with bounded backoff.
It does not blindly retry malformed requests or stable client errors.

CheapShark requires a descriptive, non-generic User-Agent.
The Actor supplies one automatically.
No proxy, browser, cookie bootstrap, account, or user credential is required.

If the source exhausts its pages before `maxItems`, the Actor finishes with the
available matching records.
An expected no-match search completes with an empty dataset.
An invalid input or unexpected upstream response fails the run visibly.

### Limits and freshness

The Actor reflects CheapShark's current API response at collection time.
It cannot guarantee that a storefront still shows the same price after a deal
changes.
Open `dealUrl` to verify before purchasing or publishing a price.

`maxItems` is capped at 1,000.
CheapShark controls source coverage, ratings, timestamps, thumbnails, store
availability, and update cadence.
This Actor does not enrich missing fields from third-party services.

The Actor does not provide all-time price history.
Build history by scheduling snapshots and retaining datasets.

### Troubleshooting

**The dataset is empty.**
Broaden the title, remove a store or rating filter, raise `maxPrice`, lower
`minimumSavings`, or disable `onlyOnSale`.
An uncommon title can legitimately have no current matching deals.

**A store ID is rejected.**
CheapShark's current stores endpoint did not recognize it.
Use a current numeric CheapShark store ID rather than a store name.

**Fewer records were returned than requested.**
The filtered source feed ended, duplicate deal IDs were removed, or records
lacked fields needed for a valid deal row.

**A run fails after retries.**
Check the run log for the final status.
Retry later if CheapShark reports a temporary rate limit or server problem;
do not add a proxy unless direct API access has actually changed.

### Responsible use and legality

CheapShark provides the anonymous API used by this Actor, but users remain
responsible for their use of the data.
Review CheapShark's current API guidance and terms, respect rate limits, and use
reasonable schedules and result limits.

Do not misrepresent stale prices as guaranteed storefront offers.
Respect storefront terms, trademarks, consumer-protection rules, and applicable
laws when republishing or commercializing deal data.
The Actor does not access accounts or personal data.

### Related Automation Lab Actors

- [Steam Games Sale Prices Scraper](https://apify.com/automation-lab/steam-game-sale-price-tracker) tracks regional Steam prices by title or app ID when a Steam-only dataset is more appropriate.

Choose the CheapShark Actor for cross-store current deal comparison.
Choose the Steam Actor when you need Steam regional pricing and app-specific
platform metadata.

### FAQ

#### Does it require a CheapShark API key?

No. It uses the public anonymous JSON interface with the descriptive client
identity requested by CheapShark.

#### Can I search several games in one run?

Yes. Add up to 20 title searches.
The Actor paginates each search and removes duplicate deal IDs globally.

#### Can I monitor prices over time?

Yes, by scheduling recurring snapshots and comparing datasets.
The Actor emits stable identifiers and timestamps but does not store or alert on
historical differences itself.

#### Are prices localized?

No. CheapShark's deal API price fields are represented as USD in this Actor.
There is no country or currency input.

#### Are null ratings an error?

No. Ratings and some external IDs are not available for every game.
Use rating filters only when you want records that meet a source-provided score.

#### Does the Actor download thumbnail images?

No. It records the source image URL, avoiding unnecessary media transfer.

#### Can I request more than 1,000 records?

Not in one run.
Split the workflow by title or store and keep the per-run limit bounded.

#### Does it follow the deal redirect?

No. It creates the CheapShark redirect URL but does not visit the destination
storefront.
This keeps extraction fast and avoids imposing storefront-specific behavior.

# Actor input Schema

## `searchQueries` (type: `array`):

Optional game title searches. Leave empty to browse the current deal feed.

## `storeIds` (type: `array`):

Optional CheapShark store IDs to include, such as 1 for Steam and 7 for GOG. Leave empty for all stores.

## `minPrice` (type: `number`):

Only return deals at or above this sale price.

## `maxPrice` (type: `number`):

Only return deals at or below this sale price.

## `minimumSavings` (type: `number`):

Minimum percentage discount from the regular price.

## `minimumMetacriticScore` (type: `integer`):

Optional minimum Metacritic score from 0 to 100.

## `minimumSteamRating` (type: `integer`):

Optional minimum positive Steam review percentage from 0 to 100.

## `onlyOnSale` (type: `boolean`):

Return only records where CheapShark marks the game as on sale.

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

CheapShark ordering applied before maxItems is reached.

## `descending` (type: `boolean`):

Reverse the selected CheapShark sort order.

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

Maximum unique deal records saved across all searches and pages.

## Actor input object example

```json
{
  "searchQueries": [
    "Civilization",
    "Batman"
  ],
  "storeIds": [
    "1",
    "7"
  ],
  "maxPrice": 30,
  "minimumSavings": 0,
  "onlyOnSale": true,
  "sortBy": "Deal Rating",
  "descending": false,
  "maxItems": 20
}
```

# Actor output Schema

## `dataset` (type: `string`):

Normalized deal records in the default dataset.

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

The main game deals dataset view.

# 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 = {
    "searchQueries": [
        "Civilization",
        "Batman"
    ],
    "storeIds": [
        "1",
        "7"
    ],
    "maxPrice": 30,
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/cheapshark-pc-game-deals").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 = {
    "searchQueries": [
        "Civilization",
        "Batman",
    ],
    "storeIds": [
        "1",
        "7",
    ],
    "maxPrice": 30,
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/cheapshark-pc-game-deals").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 '{
  "searchQueries": [
    "Civilization",
    "Batman"
  ],
  "storeIds": [
    "1",
    "7"
  ],
  "maxPrice": 30,
  "maxItems": 20
}' |
apify call automation-lab/cheapshark-pc-game-deals --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/cheapshark-pc-game-deals"
        }
    }
}
```

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/GlC8vazTwSXvikGfi/builds/LORVHZA4kcvkWVq9S/openapi.json