# Steam Game Search Scraper 🎮 - Cheap (`scrapestorm/steam-game-search-scraper---cheap`)

🎮 Quickly extract public Steam game data using any keyword, ideal for gamers, analysts & market researchers 🔍
Just enter a search term to get structured data like title, release date, platforms, rating & price
Perfect for building game databases, tracking market trends, or powering gaming tools 📈

- **URL**: https://beta-securitybyobscurity.apify.com/scrapestorm/steam-game-search-scraper---cheap.md
- **Developed by:** [Storm\_Scraper](https://beta-securitybyobscurity.apify.com/scrapestorm) (community)
- **Categories:** Automation, Social media, E-commerce
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

$14.49/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.
You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#rental-actors

# README

### 🎮 Steam Game Search & Scraper 🔍📦🔥

The Steam Game Search & Scraper is a fast and efficient tool to extract structured data from publicly listed games on Steam

### 🔍 What It Does

Just enter a search keyword and the number of games you want to fetch — the scraper will return:

✅ A list of Steam games matching the keyword
✅ Structured fields for each game, including:

| Field            | Description                                        |
| ---------------- | -------------------------------------------------- |
| `title`          | Game title                                         |
| `link`           | Full Steam URL of the game                         |
| `app_id`         | Unique Steam App ID                                |
| `platforms`      | Supported platforms (Windows, Mac, Linux)          |
| `release_date`   | Official release date                              |
| `review_score`   | Steam user rating percentage                       |
| `price`          | Current price of the game (e.g. $14.99 or "Free") |
| `original_price` | Original (non-discounted) price                    |
| `discount`       | Discount percentage, if applicable                 |
| `image_url`      | Thumbnail image of the game                        |

### 🛠 How to Use the Scraper

Using the Steam Search Scraper is quick and beginner-friendly:

Enter a keyword like "strategy", "racing", or "horror"

Choose the number of games to scrape (up to 100)

Run the scraper

Export your data to your desired format:

📦 JSON
📊 CSV
📑 Excel
🌐 XML / HTML

### 🔍 Keyword Tips

👉 Use broad keywords for larger datasets (action, free, RPG)
👉 Use niche keywords to narrow down (deckbuilder, roguelike, vr)
👉 Combine words like "open world survival", "anime fighting" for specific results

### 💰 Pricing

This scraper uses a pay-per-month model. You’re only charged for successful results.

- **Price**: $14.49 per month.

### Related Actors

If you're interested in other social media (Facebook, YouTube, Pinterest & more) or real estate Actors:

- [Apec Jobs Scraper 🔍🇫🇷 - Cheap](https://apify.com/scrapestorm/apec-jobs-scraper---cheap)
- [Jobs.ch Search Scraper (Fast & Cheap) 💼 🇨🇭](https://apify.com/scrapestorm/jobs-ch-search-scraper-fast-cheap)
- [Bundesagentur für Arbeit (Arbeitsagentur) Scraper 🇩🇪 💼 Cheap](https://apify.com/scrapestorm/bundesagentur-fur-arbeit-arbeitsagentur-scraper-cheap)
- [SimplyHired Jobs Scraper 💼🔎📈 - Faster & Cheaper](https://apify.com/scrapestorm/simplyhired-jobs-scraper---faster-cheaper)
- [Dice Jobs Scraper (Fast & Cheap) 💼](https://apify.com/scrapestorm/dice-jobs-scraper-fast-cheap)
- [Seek Job / JobStreet Scraper (Advanced & Cheap) 💼](https://apify.com/scrapestorm/seek-job-jobstreet-scraper-advanced-cheap)
- [Practo Doctor Scraper 👨‍⚕️ - Fast & Cheap](https://apify.com/scrapestorm/practo-doctor-scraper---fast-cheap)
- [PropertyFinder Search Scraper 🏡 🏘️ - Cheap](https://apify.com/scrapestorm/propertyfinder-search-scraper---cheap)
- [PropertyFinder Agent - Cheap 🏷️ 🏠👨‍💼](https://apify.com/scrapestorm/propertyfinder-agent---cheap)
- [Bayut Search Scraper 🏠](https://apify.com/scrapestorm/bayut-search-scraper---cheap)
- [🛍️ Dubizzle Search Scraper - Cheap 🏷️](https://apify.com/scrapestorm/dubizzle-search-scraper---cheap)
- [Zillow Agent Scraper (All-in-one) 🏡📧📞🤖](https://apify.com/scrapestorm/zillow-agent-scraper-all-in-one)
- [Facebook Comments Scraper (All-in-One) 💬](https://apify.com/scrapestorm/facebook-comments-scraper-all-in-one)
- [Facebook Likes Scraper (Fast & Cheap) 👍 🌟](https://apify.com/scrapestorm/facebook-likes-scraper-fast-cheap)
- [Builtin Jobs Scraper 🔍💼 - Cheap](https://apify.com/scrapestorm/builtin-jobs-scraper---cheap)
- [Pinterest Boards Search Scraper 🎨🔍](https://apify.com/scrapestorm/pinterest-boards-search-scraper)
- [Pinterest Pins/Videos Search Scraper 🎨🔍](https://apify.com/scrapestorm/pinterest-pins-videos-search-scraper)
- [Youtube Shorts Scraper 📺 (Rental) - Fast & cheap](https://apify.com/scrapestorm/youtube-shorts-scraper-rental---fast-cheap)
- [YouTube Transcript Video Scraper 📝 (⚡ Fast & 💸 Cheap)](https://apify.com/scrapestorm/youtube-transcript-videos)
- [Youtube Playlist Scraper 🎵 - Rental (Fast & cheap)](https://apify.com/scrapestorm/youtube-playlist-scraper---rental-fast-cheap)
- [Bayt Jobs Scraper 🔍💼 - Cheap)](https://apify.com/scrapestorm/bayt-jobs-scraper---cheap)

***

### 🌟 Why Use This Scraper?

📊 Market Research — Track trends in pricing, ratings, and release dates

🧠 Dataset Creation — Build datasets for ML/NLP projects related to gaming

🔎 Discovery — Explore niche titles in specific genres or tags

🔁 Automation — Keep a regularly updated feed of new or discounted games

🛒 Deal Tracking — Monitor discounts across thousands of titles

### 📥 Input Schema

Input example :

```
{
  "keyword": "strategy",
  "max_items": 50
}


```

Input Fields:

| Field       | Type    | Description                             |
| ----------- | ------- | --------------------------------------- |
| `keyword`   | string  | 🔍 Keyword to search games on Steam     |
| `max_items` | integer | 🎮 Max number of games to fetch (1–100) |

### Output Example 🧾

```
{
  "title": "World of Tanks Blitz",
  "link": "https://store.steampowered.com/app/444200/World_of_Tanks_Blitz/",
  "app_id": "444200",
  "platforms": "Windows, Mac",
  "release_date": "9 Nov, 2016",
  "review_score": "74%",
  "price": "Free",
  "original_price": "Free",
  "discount": "N/A",
  "image_url": "https://shared.fastly.steamstatic.com/store_item_assets/steam/apps/444200/501cb64165fd74f7aca258252e148d8a7234ced5/capsule_sm_120.jpg?t=1756998626"
}



```

### 📫 Support

😊 Leave us a star ⭐⭐⭐⭐⭐ if you are satisfied with the product!
🌍 For any questions, specific needs or issues, please reach out through Apify's platform or via email - [Storm\_Scraper 🌪️🌩️](https://apify.com/scrapestorm)

# Actor input Schema

## `keyword` (type: `string`):

Enter a keyword to search for items on Steam.

Example: "war", "vr", "football", etc.

## `max_items` (type: `integer`):

The maximum number of items to retrieve from the search results

## Actor input object example

```json
{
  "keyword": "war",
  "max_items": 80
}
```

# 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 = {
    "keyword": "war",
    "max_items": 80
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapestorm/steam-game-search-scraper---cheap").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 = {
    "keyword": "war",
    "max_items": 80,
}

# Run the Actor and wait for it to finish
run = client.actor("scrapestorm/steam-game-search-scraper---cheap").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "keyword": "war",
  "max_items": 80
}' |
apify call scrapestorm/steam-game-search-scraper---cheap --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scrapestorm/steam-game-search-scraper---cheap",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Steam Game Search Scraper 🎮 - Cheap",
        "description": "🎮 Quickly extract public Steam game data using any keyword, ideal for gamers, analysts & market researchers 🔍\nJust enter a search term to get structured data like title, release date, platforms, rating & price\nPerfect for building game databases, tracking market trends, or powering gaming tools 📈",
        "version": "0.0",
        "x-build-id": "QiAuFBo5BshfE5zLx"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapestorm~steam-game-search-scraper---cheap/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapestorm-steam-game-search-scraper---cheap",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/scrapestorm~steam-game-search-scraper---cheap/runs": {
            "post": {
                "operationId": "runs-sync-scrapestorm-steam-game-search-scraper---cheap",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/scrapestorm~steam-game-search-scraper---cheap/run-sync": {
            "post": {
                "operationId": "run-sync-scrapestorm-steam-game-search-scraper---cheap",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "keyword",
                    "max_items"
                ],
                "properties": {
                    "keyword": {
                        "title": "Steam Keyword 🔍",
                        "type": "string",
                        "description": "Enter a keyword to search for items on Steam.\n\nExample: \"war\", \"vr\", \"football\", etc.",
                        "default": "war"
                    },
                    "max_items": {
                        "title": "Maximum items to Fetch 📄",
                        "type": "integer",
                        "description": "The maximum number of items to retrieve from the search results",
                        "default": 80
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
