# PC Game Deals MCP Server (`mrbridge/pc-gaming-mcp`) Actor

PC game deals MCP server for Claude, ChatGPT and Cursor. Find the cheapest store for a title, compare up to 25 games, or browse deals and free giveaways, each with its lowest recorded price. Its 8 read-only tools use CheapShark price data from over a dozen stores, in US dollars.

- **URL**: https://apify.com/mrbridge/pc-gaming-mcp.md
- **Developed by:** [MrBridge](https://apify.com/mrbridge) (community)
- **Categories:** MCP servers, AI, E-commerce
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 read operations

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## PC Game Deals MCP Server

PC Game Deals MCP Server gives Claude, ChatGPT, Cursor and any other MCP client 8 read-only tools for the prices of PC games sold as digital copies. Prices come from the CheapShark API, which follows the digital stores where PC games sell (Steam, GOG, Humble Store, Fanatical and the Epic Games Store among them). Every price is in US dollars, and your Apify token is the only credential you need.

Ask Claude "Is Elden Ring under 20 dollars anywhere right now?" and it calls `game_find_best_price` with the title and a 20-dollar budget. You get the cheapest store, the price and the discount, a yes or no on the budget, the lowest price CheapShark has ever recorded for the game, and a deal link to open in your browser.

### What this server exposes

This server wraps the public CheapShark API (https://apidocs.cheapshark.com/) in 8 read-only `game_` tools about the prices of PC games sold as digital copies. CheapShark follows the digital stores listed by `game_list_stores` (14 active at the 2026-10-05 check), among them Steam, GOG, Humble Store, Fanatical and the Epic Games Store, and quotes every price in US dollars. These store names come from CheapShark's data, and none of these stores is affiliated with this server or endorses it. The tools find the cheapest offer for a title, list a game's price at each store (also from the Steam app id CheapShark records for a game, or a Steam store link), compare up to 25 games at once, browse current deals by store, price, keyword or age, list paid games given away for free, explain one deal and list the stores. Each answer gives the lowest price CheapShark has recorded, so you can tell a real low from a routine discount. The server needs no credentials and no third-party key: you connect with your Apify token, and each successful call is billed as one event. On top of the events you pay the platform usage of your own Standby run, billed to your Apify account: the memory set for the run while the server is up, idle time included, until it stops at its idle timeout (see Pricing). Every deal link goes through the CheapShark redirect page, as the CheapShark API terms require. There are no review scores, player counts, news or Minecraft profiles here: CheapShark is the only source of this server, and the other services studied were left out because of their terms.

### Tools

| Tool | What it answers | Billed event |
|---|---|---|
| `game_find_best_price` | Find the best price of a PC game | `tool-action` |
| `game_search_games` | Search PC games by title | `tool-read` |
| `game_get_game_prices` | Get the price of a PC game at every store | `tool-read` |
| `game_compare_prices` | Compare the prices of several PC games | `tool-action` |
| `game_list_deals` | Browse current PC game deals | `tool-read` |
| `game_list_free_deals` | List PC games free to keep right now | `tool-read` |
| `game_get_deal` | Get one PC game deal | `tool-read` |
| `game_list_stores` | List the stores CheapShark tracks | `tool-read` |

#### `game_find_best_price`: Find the best price of a PC game

Use this when someone asks where a PC game is cheapest right now, whether its price is the lowest ever, or whether it fits a budget. One call goes from a title to the cheapest current offer across more than a dozen digital stores (Steam, GOG, Humble, Fanatical and others), with the store, the price, the discount, the CheapShark deal link and the lowest price CheapShark has recorded. Do not use for a list of matching titles (game_search_games), for every store offer (game_get_game_prices) or for browsing deals (game_list_deals). Parameters: `title` (e.g. "elden ring", the closest CheapShark title is used and flagged when it is not exact), `max_price_usd` (optional budget in US dollars, e.g. 20), `response_format` ("detailed" adds the next cheapest offers and more candidate titles).

| Parameter | Type | Required | Example |
|---|---|---|---|
| `title` | string | yes | `"elden ring"` |
| `max_price_usd` | number | no | `20` |
| `response_format` | "concise" or "detailed" | no | `"concise"` |

Returns `{ query, game, match_note, best_offer, cheapest_ever, at_historical_low, budget, stores_with_offers, other_offers[], other_candidates[], next_steps[], attribution }`. Upstream: CheapShark. Cache: intraday (5 minutes). Read-only.

#### `game_search_games`: Search PC games by title

Use this when you need to find PC games by title in the CheapShark price catalogue and see each match with its CheapShark game id, the Steam app id CheapShark records for it and its cheapest current price, for example to tell a game from its DLC and editions. Do not use for the best offer of one game (game_find_best_price), for the price at every store (game_get_game_prices) or for browsing deals without a title (game_list_deals). Parameters: `title` (text contained in the title, e.g. "batman"), `exact_title` (true for an exact title), `limit` (1 to 60), `offset`, `response_format` ("detailed" adds the cheapest deal id and CheapShark's internal name). Prices in US dollars.

| Parameter | Type | Required | Example |
|---|---|---|---|
| `title` | string | yes | `"batman"` |
| `exact_title` | boolean | no | `false` |
| `limit` | integer | no | `20` |
| `offset` | integer | no | `0` |
| `response_format` | "concise" or "detailed" | no | `"concise"` |

Returns `{ query, exact_title, games[], pagination, next_steps[], attribution }`. Upstream: CheapShark. Cache: intraday (5 minutes). Read-only.

#### `game_get_game_prices`: Get the price of a PC game at every store

Use this when you need the current price of one PC game at every store CheapShark tracks, cheapest first, with discounts, CheapShark deal links and the lowest price ever recorded. It also takes the Steam app id CheapShark records for a game, or a Steam store link, to see whether another store sells that game for less than the Steam store. Do not use for a title you have not resolved yet (game_find_best_price or game_search_games), for several games at once (game_compare_prices) or for one deal id (game_get_deal). Give exactly one of: `game_id` (CheapShark game id, e.g. 612) or `steam_app_id` (e.g. "1245620" or "https://store.steampowered.com/app/1245620/ELDEN_RING/"). `response_format`: "concise" lists the 10 cheapest offers, "detailed" lists every offer.

| Parameter | Type | Required | Example |
|---|---|---|---|
| `game_id` | integer | no | `612` |
| `steam_app_id` | value | no | `"1245620"` |
| `response_format` | "concise" or "detailed" | no | `"concise"` |

Returns `{ game, offers[], offers_total, offers_notice, cheapest_ever, at_historical_low, other_matches[], next_steps[], attribution }`. Upstream: CheapShark. Cache: intraday (5 minutes). Read-only.

#### `game_compare_prices`: Compare the prices of several PC games

Use this when you need to compare up to 25 PC games on price in one call: for each game the cheapest current offer with its store and CheapShark deal link, the number of stores selling it, and the lowest price ever recorded, plus the cheapest game of the set. Useful for a wishlist or a shortlist. Do not use for games you only know by title (resolve them first with game_search_games or game_find_best_price) or for every offer of one game (game_get_game_prices). Parameters: `game_ids` (CheapShark game ids, 1 to 25, e.g. \[128, 129, 130]), `response_format` ("detailed" adds the 3 cheapest offers of each game).

| Parameter | Type | Required | Example |
|---|---|---|---|
| `game_ids` | array of integer | yes | `[128,129,130]` |
| `response_format` | "concise" or "detailed" | no | `"concise"` |

Returns `{ games[], not_found_ids[], cheapest_game_id, next_steps[], attribution }`. Upstream: CheapShark. Cache: intraday (5 minutes). Read-only.

#### `game_list_deals`: Browse current PC game deals

Use this when someone wants to browse current PC game deals with filters: best deals right now, deals at one or several stores, under a price, AAA games only, games CheapShark marks as redeemable on Steam, deals seen in the last hours, or a title keyword. Each row has the game, the store, the sale and normal price, the discount, CheapShark's deal rating (0 to 10) and the CheapShark deal link. Review scores are not included. Do not use for the best price of one known game (game_find_best_price), for free giveaways (game_list_free_deals) or for every store offer of one game (game_get_game_prices). Parameters: `stores` (names or ids, e.g. \["GOG"]), `title_contains` (e.g. "batman"), `exact_title`, `max_price_usd` (whole dollars 0 to 50, 50 means no limit), `min_price_usd` (whole dollars, keeps prices above it), `on_sale_only` (default true), `aaa_only` (retail price above 29 dollars), `steam_redeemable_only`, `max_age_hours` (1 to 2500), `sort_by` ("deal_rating" default, "savings", "price", "title", "release", "recent", "store"), `reverse_order` (reverses the default direction of the sort), `limit` (1 to 60), `offset` (0 to 299, the first 300 deals of a filter are reachable), `response_format` ("detailed" adds Steam app id, on-sale flag, release date, last price change and internal name).

| Parameter | Type | Required | Example |
|---|---|---|---|
| `stores` | array of string | no | `["GOG","Steam"]` |
| `title_contains` | string | no | `"batman"` |
| `exact_title` | boolean | no | `false` |
| `max_price_usd` | integer | no | `10` |
| `min_price_usd` | integer | no | `5` |
| `on_sale_only` | boolean | no | `true` |
| `aaa_only` | boolean | no | `false` |
| `steam_redeemable_only` | boolean | no | `false` |
| `max_age_hours` | integer | no | `24` |
| `sort_by` | "deal_rating" or "savings" or "price" or "title" or "release" or "recent" or "store" | no | `"deal_rating"` |
| `reverse_order` | boolean | no | `false` |
| `limit` | integer | no | `20` |
| `offset` | integer | no | `0` |
| `response_format` | "concise" or "detailed" | no | `"concise"` |

Returns `{ filters, deals[], pagination, next_steps[], attribution }`. Upstream: CheapShark. Cache: intraday (5 minutes). Read-only.

#### `game_list_free_deals`: List PC games free to keep right now

Use this when someone asks which PC games are free right now: paid games given away at 100 % off by a store (Epic Games Store, GOG, Steam and others), sorted by latest price change, each with its normal price and the CheapShark deal link. Free-to-play games are not listed. Do not use for cheap but paid deals (game_list_deals with max_price_usd) or for the price of one game (game_find_best_price). Parameters: `stores` (optional names or ids, e.g. \["Epic Games Store"]), `limit` (1 to 60), `offset` (0 to 299), `response_format` ("detailed" adds Steam app id, on-sale flag, release date, last price change and internal name). CheapShark does not say when a giveaway ends.

| Parameter | Type | Required | Example |
|---|---|---|---|
| `stores` | array of string | no | `["GOG","Steam"]` |
| `limit` | integer | no | `20` |
| `offset` | integer | no | `0` |
| `response_format` | "concise" or "detailed" | no | `"concise"` |

Returns `{ stores[], deals[], pagination, next_steps[], attribution }`. Upstream: CheapShark. Cache: intraday (5 minutes). Read-only.

#### `game_get_deal`: Get one PC game deal

Use this when you have a CheapShark deal id or deal link and need its details: game, store, sale and retail price, discount, whether other stores sell the game for less right now (with their deal links), and the lowest price ever recorded. Do not use for a game you only know by title (game_find_best_price) or for every offer of a game (game_get_game_prices). Parameters: `deal_id` (the deal id from another tool, e.g. "X8sebHhbc1Ga0dTkgg59WgyM506af9oNZZJLU9uSrX8%3D", or a https://www.cheapshark.com/redirect?dealID=... link), `response_format` ("detailed" adds the publisher and whether CheapShark marks the game as redeemable on Steam).

| Parameter | Type | Required | Example |
|---|---|---|---|
| `deal_id` | string | yes | `"X8sebHhbc1Ga0dTkgg59WgyM506af9oNZZJLU9uSrX8%3D"` |
| `response_format` | "concise" or "detailed" | no | `"concise"` |

Returns `{ deal, cheaper_offers[], is_cheapest_now, cheapest_ever, at_historical_low, next_steps[], attribution }`. Upstream: CheapShark. Cache: intraday (5 minutes). Read-only.

#### `game_list_stores`: List the stores CheapShark tracks

Use this when you need the digital PC game stores whose prices CheapShark compares (Steam, GOG, Humble Store, Fanatical, Epic Games Store and others), with their store ids and whether they are still tracked, for example to pick a store filter or to read a store id from another answer. Do not use for deals or prices (game_list_deals, game_find_best_price). Parameters: `include_inactive` (true also lists stores CheapShark no longer tracks, default false), `response_format` ("detailed" adds the time of each store's last price update).

| Parameter | Type | Required | Example |
|---|---|---|---|
| `include_inactive` | boolean | no | `false` |
| `response_format` | "concise" or "detailed" | no | `"concise"` |

Returns `{ stores[], active_count, inactive_count, next_steps[], attribution }`. Upstream: CheapShark. Cache: daily (1 day). Read-only.

### Connect

Endpoint (Streamable HTTP): `https://mrbridge--pc-gaming-mcp.apify.actor/mcp`

Every client authenticates with your Apify API token, found in [Apify Console > Settings > API & Integrations](https://console.apify.com/settings/integrations?fpr=mrbridge). Clients that support custom headers send it as `Authorization: Bearer <token>`. The others use the `?token=` URL variant, which must be treated as a secret: keep it out of commits, screenshots and shared logs.

#### Claude Code

```bash
claude mcp add --transport http pc-gaming "https://mrbridge--pc-gaming-mcp.apify.actor/mcp" --header "Authorization: Bearer ${APIFY_TOKEN}"
```

#### Cursor, VS Code and other JSON configurations

```json
{
  "mcpServers": {
    "pc-gaming": {
      "type": "http",
      "url": "https://mrbridge--pc-gaming-mcp.apify.actor/mcp",
      "headers": {
        "Authorization": "Bearer ${APIFY_TOKEN}"
      }
    }
  }
}
```

#### claude.ai and Claude Desktop

Add a custom connector with the URL `https://mrbridge--pc-gaming-mcp.apify.actor/mcp?token=YOUR_APIFY_TOKEN` and no authentication. Prefilled link (replace the token placeholder before saving): [add PC Game Deals MCP Server to Claude](https://claude.ai/customize/connectors?modal=add-custom-connector\&connectorName=PC%20Game%20Deals%20MCP%20Server\&connectorUrl=https%3A%2F%2Fmrbridge--pc-gaming-mcp.apify.actor%2Fmcp%3Ftoken%3DYOUR_APIFY_TOKEN).

#### ChatGPT (developer mode)

Settings > Apps > Create, URL `https://mrbridge--pc-gaming-mcp.apify.actor/mcp?token=YOUR_APIFY_TOKEN`, authentication "No authentication". ChatGPT snapshots the tool list: after a server update, an admin has to click Refresh on the app.

#### OpenAI Responses API

```json
{
  "type": "mcp",
  "server_label": "pc_gaming",
  "server_url": "https://mrbridge--pc-gaming-mcp.apify.actor/mcp",
  "headers": {
    "Authorization": "Bearer YOUR_APIFY_TOKEN"
  },
  "require_approval": "never"
}
```

Add `allowed_tools` to restrict the tool list. Tool calls must finish within about 60 seconds on this API, and every tool of this server answers in under 50 seconds.

#### Anthropic Messages API

```json
{
  "mcp_servers": [
    {
      "type": "url",
      "url": "https://mrbridge--pc-gaming-mcp.apify.actor/mcp",
      "name": "pc-gaming",
      "authorization_token": "YOUR_APIFY_TOKEN"
    }
  ],
  "tools": [
    {
      "type": "mcp_toolset",
      "mcp_server_name": "pc-gaming"
    }
  ]
}
```

Send the beta header `anthropic-beta: mcp-client-2025-11-20`.

#### One-click OAuth alternative

`https://mcp.apify.com/?tools=mrbridge/pc-gaming-mcp` connects through Apify OAuth without a token. It exposes the Actor as a single tool rather than the granular tools listed above.

#### Cost control

Each Standby run has a spending limit (`maxTotalChargeUsd`). When a call uses the last of it, the result is still returned, and later calls in that run answer `CHARGE_LIMIT_REACHED` until the limit is raised.

### Why use this server

Most price questions about a PC game need three answers: where it is cheapest today, whether that price is any good, and whether it fits what you want to spend. `game_find_best_price` returns all of them from a title, in one call. The "any good" part comes from `at_historical_low`, which compares today's offer with the lowest price CheapShark has seen for the game. A routine discount does not pass for a record low.

- **Already on a store page?** `game_get_game_prices` also takes a Steam app id or a Steam store link and lists the price at every store, cheapest first.
- **A wishlist in one call.** `game_compare_prices` checks up to 25 games at once and names the cheapest of the set.
- **Filters that match how people shop:** store, a price band in whole dollars, AAA only, redeemable on Steam, a title keyword, deals seen in the last few hours. Paid games given away for free have their own tool.
- No account, no third-party key and no scraping of store pages. The server calls one documented public API, one request per second, and keeps each answer five minutes.
- Every deal link goes through CheapShark's redirect page, the one condition CheapShark sets on its free API. The server never swaps it for a direct store link.

What you will not find here: review scores, box art, player counts and news. They belong to other rights holders, so they were left out on purpose.

This is an independent server, not affiliated with or endorsed by CheapShark, Valve or any store it lists.

### Pricing (Pay-per-Event)

| Event | Charged when | Price |
|---|---|---|
| `apify-actor-start` | run start (platform default) | see the Store page |
| `tool-read` (primary event) | each successful read tool call | see the Store page |
| `tool-action` | each successful call of a detailed or computed tool | see the Store page |

Never charged: initialize, tools/list, pings, readiness probes, and any call that ends in an error (invalid input, not found, upstream failure, timeout, spending limit).

Platform usage comes on top of these events. This server runs in Apify Standby mode, and you also pay the platform usage of your own Standby run, billed to your Apify account like any other run: the memory set for the Standby run, for as long as the server is up, idle time included, until the run stops at its idle timeout.
The [Apify pay-per-event documentation](https://docs.apify.com/actors/publishing/monetize/pay-per-event#platform-usage-costs) says so: "For runs in Standby mode, users always pay the platform usage costs in addition to the event charges."

### Limits, caveats and attribution

- **Attribution and links.** Each answer carries an `attribution` block naming CheapShark, its API page and three notices. Every `deal_url` is a CheapShark redirect page (`https://www.cheapshark.com/redirect?dealID=...`). Open it in a browser to reach the store. CheapShark blocks scripts and bots on that page, so an agent cannot follow it on your behalf.
- **Prices.** Prices are in US dollars, as the stores quote them to CheapShark. Regional prices, taxes and currency conversion are not covered. Stores report new prices about once an hour, and this server keeps an answer for five minutes, so check the store page before you buy.
- **Lowest price ever.** `cheapest_ever` is the lowest price CheapShark has seen since it started tracking a game, not the lowest price in the history of every store. `at_historical_low` compares the current best offer with it.
- **Not included.** User review scores, Metacritic scores and box art are left out, although CheapShark passes them along: they belong to third parties (a store, Metacritic and the publishers). There is no player count, news, ownership estimate or Minecraft data either.
- **Names.** `game_find_best_price` uses the CheapShark title closest to yours. When it is not an exact match, `match_note` says so and `other_candidates` lists the alternatives. Use `game_search_games` and a `game_id` when in doubt.
- **Searches.** CheapShark returns at most 60 games for a title search. A full answer says so: give a longer title to narrow it.
- **Deal lists.** `game_list_deals` and `game_list_free_deals` reach the first 300 deals of a filter, 60 per call. CheapShark does not give the total in a way this server can read, so `pagination.total` counts the deals seen so far until the last page. Narrow the filters to see other deals. Free giveaways come without an end date: the store page has it.
- **Rate limits.** CheapShark does not publish a number. It answers HTTP 429 with a temporary ban when a client calls too fast, and bans for good the clients that copy its whole catalogue. This server makes one call per second, retries once after a 429 only when the ban is short, once after a server error, keeps answers five minutes and never prefetches. A busy period can still answer `UPSTREAM_RATE_LIMITED`. Wait a minute and call again.
- **Store names.** Store filters take names or ids, and common other names such as "GOG.com", "Humble Bundle" or "Ubisoft" (CheapShark still calls Ubisoft Connect Uplay). "EA App" and "Battle.net" are recognised too, but they point to Origin and Blizzard Shop, which CheapShark no longer tracks, so they answer `INVALID_INPUT` without a charge. Names come from CheapShark's store list, kept a day. If that list cannot be read, prices still come back with `store_name` set to null and a notice.
- **Freshness.** Answers are kept five minutes. When CheapShark is down or rate limiting, an answer up to an hour old can be served, marked `stale` in the `cache` block.

### Data terms

CheapShark offers its API for free under one condition: deals must be linked through CheapShark's own redirect links ([CheapShark API, "Important Usage Notes"](https://apidocs.cheapshark.com/)). By using this server you agree to:

- keep the `deal_url` links as they are when you show or publish a deal, and never swap them for a direct store link,
- leave out any wording or logo that suggests CheapShark or a store endorses you or this server,
- treat prices as indications to check on the store page, since CheapShark and this server give them "as is".

This server is not affiliated with or endorsed by CheapShark, Valve or any store it lists. Game and store names belong to their owners. The fee for this server pays for the service (hosting, caching, normalisation), not for a licence on the data.

### Use cases

**Checking a wishlist before a sale.** Give Claude the titles you are waiting on. It resolves each one with `game_search_games`, sends the ids to `game_compare_prices` and tells you which games sit at their lowest recorded price today.

**Shopping on a budget.** "Show me AAA games under 10 dollars on GOG, newest deals first" maps to one `game_list_deals` call with `stores`, `max_price_usd`, `aaa_only` and `sort_by` set to `recent`.

**A weekly giveaway post.** A community manager asks which paid games are free to keep this week. `game_list_free_deals` returns them with their normal price and deal link, and the post keeps those links as they are. CheapShark gives no end date for a giveaway, so point readers to the store page.

**Comparing stores before you pay full price.** Paste the store link of the game you were about to buy. `game_get_game_prices` lists the same game at every store CheapShark tracks.

**Checking a deal someone shared.** A CheapShark deal link from a forum goes into `game_get_deal`. It tells you whether another store sells the game for less right now and what the lowest recorded price was.

**Prototyping a shopping assistant.** Through the Anthropic Messages API or the OpenAI Responses API, `allowed_tools` can limit an agent to the two or three tools it needs.

### FAQ

#### How much does it cost?

You pay per successful call. Each tool answer that succeeds is one event: `tool-action` for `game_find_best_price` and `game_compare_prices`, `tool-read` for every other tool. On the Apify free plan, a read costs 0.005 USD and an action 0.01 USD, and paid plans get lower prices, shown per plan on the Pricing tab. So 100 reads come to 0.50 USD in events. Apify also charges its standard `apify-actor-start` event when your Standby run starts.

That figure covers the events only. On top of them, Apify bills the platform usage of your own Standby run to your account at your plan's rate, as it does for every pay-per-event Actor in Standby mode: the memory set for the run (256 MB by default), for as long as the server is up, idle time included, until the run stops at its idle timeout (about 5 minutes without a call by default).

Errors cost nothing. Invalid input, a game or deal not found, an upstream failure, a timeout and the spending limit are never charged, and neither are `initialize`, `tools/list`, pings or readiness probes. Set `maxTotalChargeUsd` to cap what one run can spend in events. The [Pricing tab](https://apify.com/mrbridge/pc-gaming-mcp/pricing?fpr=mrbridge) shows the current event prices per Apify plan.

#### Is the price I see the price I will pay?

Not always. Stores report new prices to CheapShark about once an hour, and the server keeps an answer for five minutes (up to an hour when CheapShark is down, marked `stale`). Prices are in US dollars, before regional pricing, taxes and currency conversion. The store page has the final word, so open the deal link and check before you buy. A low price here is information, not buying advice.

#### Can my AI agent open the deal links for me?

No. Deal links go through CheapShark's redirect page, which blocks automated access. It is meant for people: the agent hands you the link and you open it in your browser.

#### What does the server not do?

It does not buy games, hold store accounts, sell keys or send price alerts. It returns no review scores, Metacritic scores, box art, player counts or news. It covers PC games at the digital stores CheapShark currently tracks (`game_list_stores` lists them), not consoles and not boxed copies. A store filter it cannot serve answers an error that names the store, never a silently empty list.

#### Why is the first call slower?

The first request after a quiet period is a cold start of about 4 seconds, measured on the platform tests of the server, while Apify starts your Standby run. Later calls took from a tenth of a second (an answer from the cache) to about 4 seconds for a large deal list, mostly because the server spaces its CheapShark calls one second apart. When CheapShark is busy, a call can answer `UPSTREAM_RATE_LIMITED`. That answer is not charged: wait a minute and call again.

#### What are the data terms?

CheapShark's free API comes with one condition, and the server passes it on to you in the Data terms section above: keep the `deal_url` links as they are when you show or publish a deal. Do not suggest that CheapShark or a store endorses you, and treat prices as indications to check. The server is not affiliated with or endorsed by CheapShark, Valve or any store it lists.

#### Your feedback

Found a store filter that fails, a title the search misses or a question the tools cannot answer? Open an issue on the [Issues tab](https://apify.com/mrbridge/pc-gaming-mcp/issues?fpr=mrbridge). More MCP servers, scrapers and data studies from the same team are on [mr-bridge.com](https://mr-bridge.com).

### Changelog

- 0.1.6: Output, dataset and key-value store schemas, as Apify asks for publication: the Output tab of a run started from the Console shows the connection details and one row per tool.
- 0.1.5: the Input tab shows the endpoint and how to connect an AI client, and a run started from the Console outputs the connection details and the tool list
- 0.1.4: pricing events tool-read and tool-action
- 0.1.3: the overview names the platform usage of your own Standby run next to the per-call event, as the Pricing section does
- 0.1.2: server name aligned with the Store title (connector name and connection page). Steam now appears only as data CheapShark returns: a store of its list, the Steam app id it records and its "redeemable on Steam" flag, next to a line saying none of these stores is affiliated with this server. The endpoint and the tools do not change.
- 0.1.1: the store count follows the 2026-10-05 check (more than a dozen active stores, not about 30), and the README says that "EA App" and "Battle.net" point to stores CheapShark no longer tracks
- 0.1.0: initial build (private, unpublished)

# Actor input Schema

## `mcpEndpoint` (type: `string`):

Paste this URL into your MCP client (Streamable HTTP). It is shown here for copying only: the server ignores this form, and every parameter goes in your questions.

## Actor input object example

```json
{
  "mcpEndpoint": "https://mrbridge--pc-gaming-mcp.apify.actor/mcp"
}
```

# Actor output Schema

## `connection` (type: `string`):

The item written by a run started from the Console: endpoint, token options, client recipes and the list of tools with the event each one bills.

# 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 = {
    "mcpEndpoint": "https://mrbridge--pc-gaming-mcp.apify.actor/mcp"
};

// Run the Actor and wait for it to finish
const run = await client.actor("mrbridge/pc-gaming-mcp").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 = { "mcpEndpoint": "https://mrbridge--pc-gaming-mcp.apify.actor/mcp" }

# Run the Actor and wait for it to finish
run = client.actor("mrbridge/pc-gaming-mcp").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 '{
  "mcpEndpoint": "https://mrbridge--pc-gaming-mcp.apify.actor/mcp"
}' |
apify call mrbridge/pc-gaming-mcp --silent --output-dataset

```

## MCP server setup

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

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/UNnclDEKf7eoDsZb8/builds/wLPJkgNlHXl1EgZEg/openapi.json