# CS2 Skin Price Tracker (`spry_frame/cs2-skin-scraper`) Actor

Tracks live CS2 skin prices, listings, volume, and flip margins from the Steam Community Market. Search by weapon, skin name, or keyword. No login required.

- **URL**: https://apify.com/spry\_frame/cs2-skin-scraper.md
- **Developed by:** [COSENT GROUP](https://apify.com/spry_frame) (community)
- **Categories:** Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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.

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

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

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

# README

## CS2 Skin Price Tracker

Track live CS2 skin prices from Skinport — one of the largest third-party CS2 marketplaces. Loads 25,000+ items in a single API call, filters by keyword, and surfaces buy opportunities by comparing lowest listings against suggested market price.

No login, no proxies, no rate limits.

### What it returns

- **Price Range** — lowest current listing → suggested price at a glance (e.g. `$29.69 → $41.33`)
- **Flip Spread & Flip %** — how far below suggested price the cheapest listing is. A positive flip % means someone is selling below market value — a potential buy opportunity.
- **Wear condition** — Factory New, Minimal Wear, Field-Tested, Well-Worn, Battle-Scarred
- **StatTrak detection** — StatTrak™ variants flagged automatically
- **Knife & Glove flag** — premium category items surfaced first
- **Direct links** — to both Skinport and the Steam Community Market for every item

> Results are sorted by suggested price descending by default. Switch **Sort By** to **Flip % (Best Opportunities First)** to put the best buy signals at the top.

### How to search

Enter keywords that match any part of the item name. The scraper normalizes both your input and item names — so `AK-47 Redline`, `ak47 redline`, and `AK-47 | Redline` all match the same items. Multiple keywords are each searched independently.

**Example keywords:**

- `AK-47 Redline` — all wear conditions of the AK-47 Redline
- `Karambit` — every Karambit skin and wear combination
- `Doppler Factory New` — only Factory New Doppler variants
- `StatTrak AWP` — all StatTrak AWP skins
- `Dragon Lore` — the AWP Dragon Lore across all wears

### Finding flip opportunities

The **Flip %** is calculated as:

```
Flip % = (Suggested Price - Lowest Listing) / Lowest Listing × 100
```

A high positive flip % means the cheapest listing is well below the suggested market price — either a motivated seller, a mispriced listing, or a temporarily thin market. Set **Min Flip %** to `20` or higher to filter the noise and only see actionable opportunities.

**Negative flip %** means the cheapest listing is *above* suggested price — an overpriced seller. These are filtered out when you set a minimum flip %.

### Input fields

| Field | Type | Default | Description |
|---|---|---|---|
| `keywords` | array | see defaults | Search terms matched against item names. |
| `minPrice` | number | 0 | Minimum suggested price in USD (0 = no filter). |
| `maxPrice` | number | 0 | Maximum suggested price in USD (0 = no filter). |
| `wearFilter` | array | — | Only return specific wear conditions (e.g. `Factory New`, `Field-Tested`). |
| `statTrakOnly` | boolean | false | Return only StatTrak™ variants. |
| `knivesGlovesOnly` | boolean | false | Return only knife and glove skins. |
| `minFlipPct` | integer | 0 | Minimum flip % to include. Set to 20 to show only items 20%+ below suggested price. |
| `sortBy` | select | price | Sort by suggested price or by flip % (best opportunities first). |
| `maxItems` | integer | 0 | Cap on total results (0 = no limit). |

### Example output

```json
{
  "marketHashName":  "AK-47 | Redline (Minimal Wear)",
  "weaponType":      "AK-47",
  "skinName":        "Redline",
  "wear":            "Minimal Wear",
  "isStatTrak":      "false",
  "isKnifeOrGlove":  "false",
  "priceRange":      "$139.48 → $200.78",
  "lowestPrice":     "$139.48",
  "highestPrice":    "$312.00",
  "meanPrice":       "$185.40",
  "suggestedPrice":  "$200.78",
  "quantity":        "3",
  "flipSpread":      "$61.30",
  "flipPct":         "44%",
  "skinportUrl":     "https://skinport.com/item/ak-47-redline",
  "steamMarketUrl":  "https://steamcommunity.com/market/listings/730/AK-47%20%7C%20Redline%20%28Minimal%20Wear%29",
  "scrapedAt":       "2026-08-01T07:56:57.411Z"
}
```

### Tips for traders

- **Sort by Flip %** and set **Min Flip % = 25** for a clean list of underpriced listings only.
- **Knife & Glove filter** combined with `sortBy = flipPct` is the fastest way to scan the premium market for underpriced knives.
- **Wear filter** set to `Factory New` narrows results to the most valuable condition tier.
- **StatTrak Only** toggle isolates the StatTrak market — these trade at a 2–5× premium over base versions and have their own distinct price dynamics.
- Schedule this actor daily and compare flip % trends over time to catch items that are consistently underpriced.

### Data source

Prices are sourced from the [Skinport](https://skinport.com) public API — one of the largest and most trusted third-party CS2 marketplaces. Suggested prices are Skinport's own market-derived reference values based on recent transaction history.

### About CS2 skins

CS2 (Counter-Strike 2) skins are cosmetic weapon finishes that trade on a multi-billion dollar secondary market. Prices vary by weapon type, skin design, wear condition (float value), and whether the item has a StatTrak kill counter. Knives and gloves are the highest-value category, with individual items regularly trading above $1,000.

# Actor input Schema

## `keywords` (type: `array`):

Search terms to filter skins. Each keyword is matched against the full item name. Examples: 'AK-47 | Redline', 'Karambit', 'Doppler', 'AWP | Dragon Lore'. Leave empty to use defaults.

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

Only return skins with a Steam 7-day average price at or above this value.

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

Only return skins at or below this Steam 7-day average price. Set to 0 for no limit.

## `wearFilter` (type: `array`):

Only return skins matching these wear conditions. Leave empty for all. Options: Factory New, Minimal Wear, Field-Tested, Well-Worn, Battle-Scarred.

## `statTrakOnly` (type: `boolean`):

If enabled, only returns StatTrak™ variants.

## `knivesGlovesOnly` (type: `boolean`):

If enabled, only returns knife and glove skins — the highest-value category.

## `minFlipPct` (type: `integer`):

Only return items where the flip margin is at least this percentage. E.g. set to 20 to see only items listed 20%+ below suggested price. Set to 0 for no filter.

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

How to sort results. 'price' = highest suggested price first (default). 'flipPct' = highest flip margin % first — best for spotting buy opportunities.

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

Maximum total items to return (0 = no limit).

## Actor input object example

```json
{
  "keywords": [
    "AK-47 | Redline",
    "AWP | Asiimov",
    "Karambit | Doppler"
  ],
  "minPrice": 0,
  "maxPrice": 0,
  "wearFilter": [],
  "statTrakOnly": false,
  "knivesGlovesOnly": false,
  "minFlipPct": 0,
  "sortBy": "price",
  "maxItems": 0
}
```

# Actor output Schema

## `marketHashName` (type: `string`):

Full Steam market name (e.g. StatTrak™ AK-47 | Redline (Field-Tested)).

## `weaponType` (type: `string`):

Weapon type (e.g. AK-47, AWP, Karambit).

## `skinName` (type: `string`):

Skin design name (e.g. Redline, Doppler, Dragon Lore).

## `wear` (type: `string`):

Wear condition: Factory New, Minimal Wear, Field-Tested, Well-Worn, Battle-Scarred.

## `isStatTrak` (type: `string`):

Whether the skin has a StatTrak kill counter (true/false).

## `isKnifeOrGlove` (type: `string`):

Whether this is a knife or glove skin — the highest-value category (true/false).

## `priceRange` (type: `string`):

Lowest listing → suggested price at a glance (e.g. $29.69 → $41.33).

## `lowestPrice` (type: `string`):

Cheapest current listing on Skinport.

## `highestPrice` (type: `string`):

Most expensive current listing on Skinport.

## `meanPrice` (type: `string`):

Average sale price on Skinport.

## `suggestedPrice` (type: `string`):

Skinport's suggested fair market price — the primary reference value.

## `quantity` (type: `string`):

Number of copies currently listed on Skinport — a supply indicator.

## `flipSpread` (type: `string`):

Difference between suggested price and lowest listing. Positive = potential buy opportunity below market value.

## `flipPct` (type: `string`):

Flip spread as a percentage of the lowest listing price.

## `skinportUrl` (type: `string`):

Direct link to the item on Skinport.

## `steamMarketUrl` (type: `string`):

Direct link to the item on Steam Community Market.

## `scrapedAt` (type: `string`):

Timestamp when this data was collected.

# 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 = {
    "keywords": [
        "AK-47 | Redline",
        "AWP | Asiimov",
        "Karambit | Doppler"
    ],
    "wearFilter": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("spry_frame/cs2-skin-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 = {
    "keywords": [
        "AK-47 | Redline",
        "AWP | Asiimov",
        "Karambit | Doppler",
    ],
    "wearFilter": [],
}

# Run the Actor and wait for it to finish
run = client.actor("spry_frame/cs2-skin-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 '{
  "keywords": [
    "AK-47 | Redline",
    "AWP | Asiimov",
    "Karambit | Doppler"
  ],
  "wearFilter": []
}' |
apify call spry_frame/cs2-skin-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/otb9ceZpxFJMmbMBD/builds/iiweLluoKLxeEun06/openapi.json