# Steam Community Market Scraper (`fetch_cat/steam-community-market-scraper`) Actor

Scrape public Steam Community Market item prices, listing counts, app metadata, item hash names, icons, URLs, and diagnostics.

- **URL**: https://apify.com/fetch\_cat/steam-community-market-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** E-commerce, Automation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.30 / 1,000 market items

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/platform/actors/running/actors-in-store#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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use 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

## Steam Community Market Scraper

Steam Community Market Scraper exports public market item search results with current listing counts, price text, app metadata, item hash names, icon URLs, and diagnostics. Use it to build trading dashboards, monitor item families, compare marketable game assets, and research public Steam marketplace inventory.

### What data it exports

- Searches public Steam Community Market item listings by keyword.
- Returns market item identifiers, app/game fields, listing counts, price text, and direct market URLs.
- Supports exact item watchlists for known `appId` + `marketHashName` pairs.
- Adds diagnostics for zero-result searches and failed pages when requested.

### Use cases

- **Game traders:** Watch popular item families, cases, stickers, capsules, and skins.
- **Market analysts:** Export price/listing snapshots for spreadsheet and BI workflows.
- **Game publishers:** Monitor public market activity around game items.
- **Pricing researchers:** Compare availability and price text across keywords and apps.

### At a glance

- **Search market items:** Run one or more Steam Community Market keyword searches.
- **Monitor exact items:** Submit known `appId` + `marketHashName` entries for watchlists.
- **Export clean data:** Download CSV, JSON, Excel, XML, or consume results through the Apify API.
- **Stay bounded:** Limit rows per query and keep duplicate market items out of the dataset.
- **Know what happened:** Optional diagnostic rows explain empty searches or failed pages.

### Input example

```json
{
  "queries": ["case"],
  "appId": 730,
  "maxItemsPerQuery": 10,
  "countPerPage": 10,
  "dedupe": true,
  "includeDiagnostics": true
}
````

### Output example

```json
{
  "query": "case",
  "rank": 1,
  "name": "Dreams & Nightmares Case",
  "marketHashName": "Dreams & Nightmares Case",
  "appId": 730,
  "appName": "Counter-Strike 2",
  "sellListings": 348508,
  "sellPrice": 185,
  "sellPriceText": "$1.85",
  "marketUrl": "https://steamcommunity.com/market/listings/730/Dreams%20%26%20Nightmares%20Case",
  "status": "ok",
  "warnings": [],
  "scrapedAt": "2026-07-21T08:00:00.000Z"
}
```

### Input settings

| Key | Type | Description |
| --- | --- | --- |
| `queries` | string\[] | Steam Community Market keywords such as `case`, `ak-47`, `capsule`, or `sticker`. |
| `maxItemsPerQuery` | integer | Maximum saved market item rows for each query. |
| `startPage` | integer | Zero-based page to start from. |
| `countPerPage` | integer | Search page size, from 1 to 10. |
| `appId` | integer | Optional Steam app ID filter, for example `730` for Counter-Strike 2. |
| `exactItems` | object\[] | Optional watchlist entries with `appId` and `marketHashName`. |
| `dedupe` | boolean | Skip duplicate `appId + marketHashName` rows across queries. |
| `includeDiagnostics` | boolean | Save non-charged diagnostic rows for empty searches and failed pages. |
| `proxyConfiguration` | object | Optional Apify proxy settings. Leave disabled for normal small runs. |

### Output fields

| Field | Description |
| --- | --- |
| `query`, `rank` | Search term and rank within that query/page sequence. |
| `name`, `hashName`, `marketHashName` | Steam market item names and hash names. |
| `appId`, `appName`, `classId` | Steam game/app and asset identity fields. |
| `sellListings` | Current public listing count returned by Steam. |
| `sellPrice`, `sellPriceText`, `salePriceText` | Numeric cents when parseable plus original price text. |
| `tradable`, `itemType`, `itemNameColor` | Public item metadata when returned by Steam. |
| `iconUrl`, `marketUrl`, `sourceUrl` | Item image, Steam market listing, and source request URLs. |
| `status`, `warnings`, `missingFields` | Result or diagnostic status and parsing notes. |
| `scrapedAt` | Timestamp when the row was saved. |

### Input recipes

- **CS2 case watchlist:** `{"queries":["case"],"appId":730,"maxItemsPerQuery":25,"countPerPage":10}`
- **Keyword discovery:** `{"queries":["sticker","capsule"],"maxItemsPerQuery":15,"dedupe":true}`
- **Exact item monitor:** `{"exactItems":[{"appId":730,"marketHashName":"Dreams & Nightmares Case"}],"maxItemsPerQuery":5}`

### Pricing

This Actor uses pay-per-event pricing. A small start fee is charged once per run, and only saved market item rows are charged as results. Diagnostic-only rows are not charged as result items.

| Event | Price |
| --- | ---: |
| Run start | $0.005 |
| Market item result | FREE $0.000575, BRONZE $0.0005, SILVER $0.00039, GOLD $0.0003, PLATINUM $0.0002, DIAMOND $0.00014 per item |

### Tips and limits

- Steam price text can vary by locale and availability; keep the raw text fields for audits.
- Use small `maxItemsPerQuery` values for frequent monitoring tasks.
- This Actor covers public Community Market item data, not private inventories, trades, wallets, or purchases.
- Empty searches can be valid. Enable `includeDiagnostics` when building monitoring pipelines.

### API usage

**Node.js**

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/steam-community-market-scraper').call({
  queries: ['case'],
  appId: 730,
  maxItemsPerQuery: 10
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

**Python**

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('fetch_cat/steam-community-market-scraper').call(run_input={
    'queries': ['case'],
    'appId': 730,
    'maxItemsPerQuery': 10,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
```

**cURL**

```bash
curl -X POST 'https://api.apify.com/v2/acts/fetch_cat~steam-community-market-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"queries":["case"],"appId":730,"maxItemsPerQuery":10}'
```

### MCP and agents

Use this Actor from agents through Apify MCP with the tool-filtered URL:

```text
https://mcp.apify.com/?tools=fetch_cat/steam-community-market-scraper
```

**Claude CLI**

```bash
claude mcp add apify 'https://mcp.apify.com/?tools=fetch_cat/steam-community-market-scraper'
```

**JSON config**

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?tools=fetch_cat/steam-community-market-scraper"
    }
  }
}
```

**Example prompts**

- "Find current Steam Community Market listings for CS2 cases and return listing counts."
- "Monitor Dreams & Nightmares Case and summarize the current price text."
- "Export Steam market item rows for sticker and capsule searches as JSON."

### Related actors

- [Steam Reviews Scraper](https://apify.com/fetch_cat/steam-reviews-scraper) for public Steam game review data.
- [Steam Store Games Scraper](https://apify.com/fetch_cat/steam-store-games-scraper) for Steam Store game metadata and pricing.

### Responsible use

Scrape only public Steam Community Market data. Do not use this Actor to collect private account, inventory, wallet, trade, or purchase information. Respect Steam's terms and run modest, bounded workloads.

### FAQ

**Does it require a Steam login?** No. It is designed for public market data.

**Can it return historical charts?** Not in V1. Current public listing counts and price text are supported.

**Why is `sellPrice` sometimes null?** Localized or unusual price text may not parse cleanly. The raw `sellPriceText` is still preserved.

### Support

Open an issue on the Actor page and include:

- Run ID or reproducible public URL.
- Input JSON you used.
- Expected output.
- Actual output or error message.

# Actor input Schema

## `queries` (type: `array`):

Steam Community Market keywords such as case, ak-47, capsule, sticker, or item family names.

## `maxItemsPerQuery` (type: `integer`):

How many market item rows to save for each search query.

## `startPage` (type: `integer`):

Zero-based page number to start from.

## `countPerPage` (type: `integer`):

Steam page size for each market request. Lower values are gentler; higher values reduce pagination requests.

## `appId` (type: `integer`):

Optional app ID filter, for example 730 for Counter-Strike 2.

## `exactItems` (type: `array`):

Optional exact item watchlist. Each entry needs appId and marketHashName.

## `dedupe` (type: `boolean`):

Remove duplicate appId + marketHashName rows across overlapping queries.

## `includeDiagnostics` (type: `boolean`):

Save non-charged diagnostic rows for empty queries and failed pages.

## `proxyConfiguration` (type: `object`):

Optional Apify proxy configuration. Leave default unless Steam rate limits your workload.

## Actor input object example

```json
{
  "queries": [
    "case"
  ],
  "maxItemsPerQuery": 10,
  "startPage": 0,
  "countPerPage": 10,
  "dedupe": true,
  "includeDiagnostics": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (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 = {
    "queries": [
        "case"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/steam-community-market-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 = { "queries": ["case"] }

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/steam-community-market-scraper").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 '{
  "queries": [
    "case"
  ]
}' |
apify call fetch_cat/steam-community-market-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Steam Community Market Scraper",
        "description": "Scrape public Steam Community Market item prices, listing counts, app metadata, item hash names, icons, URLs, and diagnostics.",
        "version": "0.1",
        "x-build-id": "quDWf4n0qiMYRLKMy"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~steam-community-market-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-steam-community-market-scraper",
                "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/fetch_cat~steam-community-market-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-steam-community-market-scraper",
                "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/fetch_cat~steam-community-market-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-steam-community-market-scraper",
                "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",
                "properties": {
                    "queries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Steam Community Market keywords such as case, ak-47, capsule, sticker, or item family names.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItemsPerQuery": {
                        "title": "Maximum market items per query",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "How many market item rows to save for each search query.",
                        "default": 10
                    },
                    "startPage": {
                        "title": "Start page",
                        "minimum": 0,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Zero-based page number to start from.",
                        "default": 0
                    },
                    "countPerPage": {
                        "title": "Items per page",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Steam page size for each market request. Lower values are gentler; higher values reduce pagination requests.",
                        "default": 10
                    },
                    "appId": {
                        "title": "Steam app ID filter",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Optional app ID filter, for example 730 for Counter-Strike 2."
                    },
                    "exactItems": {
                        "title": "Exact market items",
                        "type": "array",
                        "description": "Optional exact item watchlist. Each entry needs appId and marketHashName.",
                        "items": {
                            "type": "object",
                            "required": [
                                "appId",
                                "marketHashName"
                            ],
                            "properties": {
                                "appId": {
                                    "type": "integer",
                                    "title": "Steam app ID",
                                    "description": "Steam application ID for this exact market item."
                                },
                                "marketHashName": {
                                    "type": "string",
                                    "title": "Market hash name",
                                    "description": "Exact Steam Community Market hash name to search."
                                },
                                "query": {
                                    "type": "string",
                                    "title": "Optional search query override",
                                    "description": "Optional query text if it differs from the market hash name."
                                }
                            }
                        }
                    },
                    "dedupe": {
                        "title": "Deduplicate market items",
                        "type": "boolean",
                        "description": "Remove duplicate appId + marketHashName rows across overlapping queries.",
                        "default": true
                    },
                    "includeDiagnostics": {
                        "title": "Include diagnostic rows",
                        "type": "boolean",
                        "description": "Save non-charged diagnostic rows for empty queries and failed pages.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify proxy configuration. Leave default unless Steam rate limits your workload.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
