# CS2 Steam Market Price Tracker (`automation-lab/cs2-steam-market-price-tracker`) Actor

Track CS2 Steam Market prices, listing counts, and price changes for skin trading watchlists and arbitrage workflows.

- **URL**: https://apify.com/automation-lab/cs2-steam-market-price-tracker.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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

## CS2 Steam Market Price Tracker

Track Counter-Strike 2 Steam Community Market prices, listing counts, and watchlist changes with clean Apify datasets.

### What does CS2 Steam Market Price Tracker do?

CS2 Steam Market Price Tracker extracts public Counter-Strike 2 market search data from the Steam Community Market for appid `730`. It turns market search results into structured rows with numeric prices, listing counts, item metadata, direct Steam Market URLs, icon URLs, and timestamps.

Use it when you need repeatable CS2 skin price snapshots instead of manually copying values from Steam pages. The actor works with broad search queries such as `AK-47`, `Case`, or `Doppler`, and with exact market hash names such as `AK-47 | Redline (Field-Tested)` or `Fracture Case`.

### Why use it for CS2 market monitoring?

Steam Market is useful in a browser, but it is not designed for scheduled analysis, alerting, or spreadsheet exports. This actor gives you a consistent dataset that can be exported to CSV, JSON, Excel, API integrations, webhooks, and MCP clients.

Typical uses include:

- tracking lowest sell prices for a skin watchlist,
- watching listing counts as a liquidity signal,
- comparing current prices against a reference spreadsheet,
- creating hourly or daily snapshots for dashboards,
- feeding Discord, Slack, Telegram, or trading-bot alerts.

### Who is it for?

#### CS2 skin traders

Traders can monitor a focused watchlist of skins, cases, stickers, capsules, gloves, and knives. Add exact `marketHashNames`, include `referencePrices`, and export `priceChange` plus `priceChangePercent` for alert rules.

#### Collectors and portfolio managers

Collectors can schedule daily snapshots for inventory-adjacent items and track whether target items move into a desired price range. Listing counts help distinguish a thin market from a liquid one.

#### Marketplace analysts

Analysts can run broad searches like `Case`, `Doppler`, `Sticker`, `AWP`, or `M4A1-S` and compare price distributions across result pages. The output is normalized enough for BI tools and notebooks.

#### Discord community operators

Community operators can connect Apify webhooks to bots and post watchlist updates when an item drops below a threshold, rises above a reference price, or changes listing count materially.

#### Automation builders

Bot developers can use the actor as a clean public-data source for Steam Market search snapshots. It does not log in, buy, sell, inspect private inventories, or bypass Steam restrictions.

### What data can you extract?

The default dataset contains one row per Steam Market result that passes your filters.

| Field | Description |
| --- | --- |
| `searchQuery` | Query or exact market hash name that produced the row. |
| `resultRank` | Rank within the collected result stream. |
| `marketHashName` | Steam market hash name. |
| `itemName` | Human-readable item name. |
| `sellListings` | Number of current sell listings when Steam provides it. |
| `sellPriceText` | Formatted price text returned by Steam. |
| `sellPrice` | Parsed numeric lowest sell price. |
| `currencyId` | Steam currency ID used for the request. |
| `referencePrice` | Optional baseline supplied by you. |
| `priceChange` | Current price minus reference price. |
| `priceChangePercent` | Percent change against reference price. |
| `marketUrl` | Direct Steam Community Market listing URL. |
| `weaponOrItemType` | Parsed item type when available from CS2 tags. |
| `exterior` | Exterior / wear tag when available. |
| `rarity` | Rarity tag when available. |
| `iconUrl` | Steam CDN icon URL. |
| `scrapedAt` | ISO timestamp for the snapshot. |

### How much does it cost to track CS2 Steam Market prices?

This actor uses pay-per-event pricing: a small start event plus a low per-item event. Your exact charge depends on your Apify plan tier and the number of market items saved.

| Event | FREE | BRONZE | SILVER | GOLD | PLATINUM | DIAMOND |
| --- | ---: | ---: | ---: | ---: | ---: | ---: |
| Run start | $0.005000 | $0.005000 | $0.005000 | $0.005000 | $0.005000 | $0.005000 |
| Each item extracted | $0.000030186 | $0.000026249 | $0.000020474 | $0.000015749 | $0.000010500 | $0.000010000 |

Example gross actor charges before Apify platform fees:

| Example run | Items | FREE estimate | BRONZE estimate | GOLD estimate |
| --- | ---: | ---: | ---: | ---: |
| Small watchlist | 10 | ~$0.0053 | ~$0.0053 | ~$0.0052 |
| Default discovery run | 50 | ~$0.0065 | ~$0.0063 | ~$0.0058 |
| Larger market scan | 120 | ~$0.0086 | ~$0.0081 | ~$0.0069 |
| Broad scheduled scan | 500 | ~$0.0201 | ~$0.0181 | ~$0.0129 |

To keep costs predictable, start with a small `maxItems` value, confirm the output shape, and then raise `maxItems` or `maxPagesPerQuery` for production monitoring.

### Input overview

You can use either broad discovery queries, exact watchlist items, or both.

| Input | Use it for |
| --- | --- |
| `searchQueries` | Broad Steam Market searches such as `AK-47`, `Case`, or `Sticker`. |
| `marketHashNames` | Exact watchlist items such as `Fracture Case`. |
| `currency` | Steam currency ID. The default is usually USD. |
| `maxItems` | Maximum rows to save across the run. |
| `resultsPerPage` | Steam search page size. |
| `maxPagesPerQuery` | Pagination limit per query. |
| `minPrice` / `maxPrice` | Optional numeric price filters. |
| `referencePrices` | Baseline prices for change calculations. |
| `requestDelayMs` | Delay between Steam requests. |

### Example input: small discovery run

```json
{
  "searchQueries": ["AK-47", "Case"],
  "currency": 1,
  "maxItems": 50,
  "resultsPerPage": 50,
  "maxPagesPerQuery": 1,
  "requestDelayMs": 750
}
````

### Example input: exact watchlist with reference prices

```json
{
  "marketHashNames": [
    "AK-47 | Redline (Field-Tested)",
    "Fracture Case",
    "M4A1-S | Decimator (Field-Tested)"
  ],
  "referencePrices": {
    "AK-47 | Redline (Field-Tested)": 28.5,
    "Fracture Case": 0.55,
    "M4A1-S | Decimator (Field-Tested)": 14.25
  },
  "currency": 1,
  "maxItems": 25,
  "requestDelayMs": 1000
}
```

### How to run the actor in the Apify Console

1. Open the actor page on Apify.
2. Add one or more `searchQueries` or `marketHashNames`.
3. Choose a Steam currency ID.
4. Keep `maxItems` small for the first run.
5. Run the actor.
6. Open the Dataset tab and export the results as CSV, JSON, Excel, RSS, or via API.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const input = {
  searchQueries: ['AK-47', 'Case'],
  marketHashNames: ['AK-47 | Redline (Field-Tested)'],
  referencePrices: {
    'AK-47 | Redline (Field-Tested)': 28.5,
  },
  currency: 1,
  maxItems: 50,
  resultsPerPage: 50,
  maxPagesPerQuery: 1,
  requestDelayMs: 750,
};

const run = await client.actor('automation-lab/cs2-steam-market-price-tracker').call(input);
const { items } = await client.dataset(run.defaultDatasetId).listItems({ limit: 100 });

for (const item of items) {
  console.log(item.marketHashName, item.sellPrice, item.sellListings, item.marketUrl);
}
```

### API usage with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])

run_input = {
    'searchQueries': ['Doppler', 'Sticker'],
    'marketHashNames': ['Fracture Case'],
    'referencePrices': {'Fracture Case': 0.55},
    'currency': 1,
    'maxItems': 75,
    'resultsPerPage': 50,
    'maxPagesPerQuery': 2,
    'requestDelayMs': 1000,
}

run = client.actor('automation-lab/cs2-steam-market-price-tracker').call(run_input=run_input)
items = client.dataset(run['defaultDatasetId']).list_items(limit=100).items

for item in items:
    print(item['marketHashName'], item.get('sellPrice'), item.get('priceChangePercent'))
```

### API usage with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~cs2-steam-market-price-tracker/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{
    "searchQueries": ["AK-47", "Case"],
    "marketHashNames": ["AK-47 | Redline (Field-Tested)"],
    "currency": 1,
    "maxItems": 50,
    "resultsPerPage": 50,
    "maxPagesPerQuery": 1,
    "requestDelayMs": 750
  }'
```

After the run succeeds, fetch items from the run's `defaultDatasetId`:

```bash
curl "https://api.apify.com/v2/datasets/DATASET_ID/items?clean=true&format=json&token=$APIFY_TOKEN"
```

### MCP usage

Use the Apify MCP server with this actor when you want Claude Code, Claude Desktop, or another MCP-compatible client to run a market check for you.

Claude Code setup:

```bash
claude mcp add apify https://mcp.apify.com/?tools=automation-lab/cs2-steam-market-price-tracker
```

Claude Desktop configuration:

```json
{
  "mcpServers": {
    "apify-cs2-market": {
      "url": "https://mcp.apify.com/?tools=automation-lab/cs2-steam-market-price-tracker"
    }
  }
}
```

Example prompts:

- "Run the CS2 Steam Market Price Tracker for AK-47 and Case items and summarize the cheapest rows."
- "Check my watchlist against these reference prices and show items down more than 5%."
- "Export a CS2 market snapshot for Fracture Case and M4A1-S items that I can paste into a spreadsheet."

### Watchlist monitoring workflow

For recurring monitoring, create a saved Apify task with `marketHashNames` and `referencePrices`. Schedule it hourly, every six hours, or daily depending on how frequently you need market updates.

A practical workflow is:

1. maintain a spreadsheet of market hash names and target prices,
2. pass that list to this actor,
3. export the dataset after every run,
4. compare `priceChangePercent` to your alert thresholds,
5. send matches to Discord, Slack, Telegram, email, or a webhook endpoint.

### Arbitrage research workflow

For broader discovery, use search terms that represent item families rather than exact items. Examples include `Case`, `Sticker`, `Doppler`, `AWP`, `Knife`, `Gloves`, `M4A1-S`, and `AK-47`.

Sort the resulting dataset by `sellPrice`, `sellListings`, `rarity`, or `priceChangePercent`. Treat the actor as a public market-data collector; it does not determine whether a trade is safe or profitable.

### Price filtering tips

Use `minPrice` and `maxPrice` when you only care about a specific trading range. For example, a collector looking for items between $5 and $50 can filter before export and avoid downstream spreadsheet cleanup.

If Steam does not provide a parseable price for a row, the actor keeps the row unless your price filter requires a numeric comparison. This makes missing-price cases visible instead of silently hiding them.

### Reliability tips

Steam may temporarily slow down, omit fields, or rate-limit aggressive request patterns. For reliable scheduled jobs:

- keep `requestDelayMs` at 750 ms or higher,
- avoid unnecessarily large `maxPagesPerQuery` values,
- split very large watchlists into multiple scheduled tasks,
- start with `maxItems` of 50 to 120 and increase only when needed,
- retry later if Steam returns temporary server errors.

### Integrations

The actor works well with:

- Apify schedules for recurring snapshots,
- Apify webhooks for alert pipelines,
- Google Sheets or Airtable for watchlist review,
- BI tools for price and listing-count history,
- Discord or Slack bots for community notifications,
- custom trading dashboards that read the dataset API.

### Output example

```json
{
  "searchQuery": "AK-47",
  "resultRank": 1,
  "marketHashName": "AK-47 | Redline (Field-Tested)",
  "itemName": "AK-47 | Redline",
  "sellListings": 1284,
  "sellPriceText": "$28.63",
  "sellPrice": 28.63,
  "currencyId": 1,
  "referencePrice": 28.5,
  "priceChange": 0.13,
  "priceChangePercent": 0.46,
  "marketUrl": "https://steamcommunity.com/market/listings/730/AK-47%20%7C%20Redline%20%28Field-Tested%29",
  "weaponOrItemType": "Rifle",
  "exterior": "Field-Tested",
  "rarity": "Classified",
  "iconUrl": "https://community.cloudflare.steamstatic.com/economy/image/...",
  "scrapedAt": "2026-07-05T02:45:00.000Z"
}
```

### Limitations

This actor reads public Steam Community Market search data. It does not log in to Steam, inspect private inventories, place buy orders, place sell orders, read trade history, or guarantee the accuracy of third-party trading decisions.

Steam controls the public market endpoint and can change response fields, rate limits, or availability. If a row is missing a price or tag, the actor preserves the available fields and leaves the unavailable values empty.

### Legality and responsible use

Use this actor for lawful market research and monitoring of publicly available Steam Market pages. Respect Steam's terms, avoid excessive request rates, and do not use the output for fraud, spam, market manipulation, or attempts to bypass platform rules.

### Troubleshooting

#### Why did my query return no rows?

Check the spelling of the market item. Exact market names must match Steam's wording, punctuation, and wear text. If in doubt, try a broader `searchQueries` value first and copy the returned `marketHashName` into your watchlist.

#### Why is `sellPrice` missing for some rows?

Steam sometimes returns formatted rows without a parseable lowest sell price. The actor keeps those rows with `sellPriceText` or metadata where available so you can review them instead of losing the result.

#### How do I reduce run cost?

Lower `maxItems`, lower `maxPagesPerQuery`, and use exact `marketHashNames` instead of broad discovery queries. The start event is fixed per run, so group small watchlist items into one scheduled task when possible.

#### Can I use a non-USD currency?

Yes. Set the Steam `currency` ID to the currency you need. The actor records that ID in `currencyId` and stores the formatted price text returned by Steam.

### Related automation-lab actors

These related actors can support marketplace or gaming research workflows:

- [Steam Scraper](https://apify.com/automation-lab/steam-scraper) for public Steam app and store data.
- [Steam Game Reviews Scraper](https://apify.com/automation-lab/steam-game-reviews-scraper) for Steam review analysis.
- [eBay Scraper](https://apify.com/automation-lab/ebay-scraper) for marketplace listing comparisons outside Steam.
- [eBay Sold Listings Scraper](https://apify.com/automation-lab/ebay-sold-scraper) for realized marketplace sale-price research.
- [Prisjakt Price Comparison Scraper](https://apify.com/automation-lab/prisjakt-price-comparison-scraper) for price-comparison monitoring patterns.

### Links

- Actor: https://apify.com/automation-lab/cs2-steam-market-price-tracker
- MCP: https://mcp.apify.com/?tools=automation-lab/cs2-steam-market-price-tracker
- Steam Community Market: https://steamcommunity.com/market/

### FAQ

#### Does the actor require Steam cookies?

No. The MVP uses public unauthenticated Steam Community Market search data.

#### Can it monitor exact skins?

Yes. Use `marketHashNames` for exact skins, cases, stickers, capsules, knives, or gloves.

#### Can it calculate price changes?

Yes. Provide `referencePrices` keyed by market hash name. The actor outputs `priceChange` and `priceChangePercent` when a current numeric price and reference price are both available.

#### Can it buy or sell items?

No. It only extracts public market data and stores it in an Apify dataset.

#### What is the safest first run?

Use one query, `maxItems` between 10 and 50, and the default delay. Review the dataset, then expand the input for scheduled monitoring.

# Actor input Schema

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

Steam Market search terms for CS2 items. Examples: AK-47, Doppler, Kilowatt Case.

## `marketHashNames` (type: `array`):

Optional exact CS2 item names to monitor. These are searched one by one and matched preferentially by exact name.

## `currency` (type: `integer`):

Steam currency ID used by the market endpoint. 1=USD, 2=GBP, 3=EUR, 5=RUB, 7=BRL, 20=CNY.

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

Only save items at or above this parsed sell price. Leave empty to disable.

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

Only save items at or below this parsed sell price. Leave empty to disable.

## `referencePrices` (type: `object`):

Optional object mapping exact item names to your previous/reference price. The actor outputs absolute and percent change.

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

Maximum market records to save across all searches and watchlist items.

## `maxPagesPerQuery` (type: `integer`):

Each Steam Market page contains up to 100 results. Raise this for broad searches.

## `resultsPerPage` (type: `integer`):

Steam page size. The actor caps this at 100 to match the public endpoint.

## `requestDelayMs` (type: `integer`):

Polite delay between Steam Market requests. Increase if Steam returns rate-limit errors.

## Actor input object example

```json
{
  "searchQueries": [
    "AK-47",
    "Kilowatt Case"
  ],
  "marketHashNames": [
    "AK-47 | Redline (Field-Tested)",
    "Fracture Case"
  ],
  "currency": 1,
  "referencePrices": {
    "AK-47 | Redline (Field-Tested)": 22.5,
    "Fracture Case": 0.35
  },
  "maxItems": 20,
  "maxPagesPerQuery": 2,
  "resultsPerPage": 100,
  "requestDelayMs": 750
}
```

# 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 = {
    "searchQueries": [
        "AK-47",
        "Kilowatt Case"
    ],
    "marketHashNames": [
        "AK-47 | Redline (Field-Tested)",
        "Fracture Case"
    ],
    "currency": 1,
    "referencePrices": {
        "AK-47 | Redline (Field-Tested)": 22.5,
        "Fracture Case": 0.35
    },
    "maxItems": 20,
    "maxPagesPerQuery": 2,
    "resultsPerPage": 100,
    "requestDelayMs": 750
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/cs2-steam-market-price-tracker").call(input);

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "searchQueries": [
        "AK-47",
        "Kilowatt Case",
    ],
    "marketHashNames": [
        "AK-47 | Redline (Field-Tested)",
        "Fracture Case",
    ],
    "currency": 1,
    "referencePrices": {
        "AK-47 | Redline (Field-Tested)": 22.5,
        "Fracture Case": 0.35,
    },
    "maxItems": 20,
    "maxPagesPerQuery": 2,
    "resultsPerPage": 100,
    "requestDelayMs": 750,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/cs2-steam-market-price-tracker").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 '{
  "searchQueries": [
    "AK-47",
    "Kilowatt Case"
  ],
  "marketHashNames": [
    "AK-47 | Redline (Field-Tested)",
    "Fracture Case"
  ],
  "currency": 1,
  "referencePrices": {
    "AK-47 | Redline (Field-Tested)": 22.5,
    "Fracture Case": 0.35
  },
  "maxItems": 20,
  "maxPagesPerQuery": 2,
  "resultsPerPage": 100,
  "requestDelayMs": 750
}' |
apify call automation-lab/cs2-steam-market-price-tracker --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "CS2 Steam Market Price Tracker",
        "description": "Track CS2 Steam Market prices, listing counts, and price changes for skin trading watchlists and arbitrage workflows.",
        "version": "0.1",
        "x-build-id": "YwgFVJfGryfSqZGfQ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~cs2-steam-market-price-tracker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-cs2-steam-market-price-tracker",
                "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/automation-lab~cs2-steam-market-price-tracker/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-cs2-steam-market-price-tracker",
                "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/automation-lab~cs2-steam-market-price-tracker/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-cs2-steam-market-price-tracker",
                "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": {
                    "searchQueries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Steam Market search terms for CS2 items. Examples: AK-47, Doppler, Kilowatt Case.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "marketHashNames": {
                        "title": "Exact market hash names / watchlist",
                        "type": "array",
                        "description": "Optional exact CS2 item names to monitor. These are searched one by one and matched preferentially by exact name.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "currency": {
                        "title": "Steam currency ID",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Steam currency ID used by the market endpoint. 1=USD, 2=GBP, 3=EUR, 5=RUB, 7=BRL, 20=CNY.",
                        "default": 1
                    },
                    "minPrice": {
                        "title": "Minimum price",
                        "minimum": 0,
                        "type": "number",
                        "description": "Only save items at or above this parsed sell price. Leave empty to disable."
                    },
                    "maxPrice": {
                        "title": "Maximum price",
                        "minimum": 0,
                        "type": "number",
                        "description": "Only save items at or below this parsed sell price. Leave empty to disable."
                    },
                    "referencePrices": {
                        "title": "Reference prices for change tracking",
                        "type": "object",
                        "description": "Optional object mapping exact item names to your previous/reference price. The actor outputs absolute and percent change."
                    },
                    "maxItems": {
                        "title": "Maximum items",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum market records to save across all searches and watchlist items.",
                        "default": 20
                    },
                    "maxPagesPerQuery": {
                        "title": "Maximum pages per query",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Each Steam Market page contains up to 100 results. Raise this for broad searches.",
                        "default": 2
                    },
                    "resultsPerPage": {
                        "title": "Results per page",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Steam page size. The actor caps this at 100 to match the public endpoint.",
                        "default": 100
                    },
                    "requestDelayMs": {
                        "title": "Delay between requests (ms)",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Polite delay between Steam Market requests. Increase if Steam returns rate-limit errors.",
                        "default": 750
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
