# CS2 Skin Prices API: Skinport, DMarket, Steam & CSFloat (`varnmill/cs2-skin-prices`) Actor

CS2 (CS:GO) skin prices from Skinport, DMarket, Waxpeer, Market.CSGO, LIS-SKINS, Steam and optionally CSFloat in one row per item: lowest asks, DMarket buy orders, listings, Skinport sales history, cross-venue spreads and the best flip after fees. No login or API key needed for six venues.

- **URL**: https://apify.com/varnmill/cs2-skin-prices.md
- **Developed by:** [Jay Novello](https://apify.com/varnmill) (community)
- **Categories:** Games, E-commerce, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.63 / 1,000 item priceds

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## CS2 Skin Prices API: Skinport, DMarket, Steam & CSFloat

Counter-Strike 2 skin prices from Skinport, DMarket, Waxpeer, Market.CSGO, LIS-SKINS and the Steam Community Market in one row per item (lowest ask per venue, listings, DMarket buy orders, Skinport sales history, cross-venue spread and the best flip after fees), from each marketplace's public price feed, with no login or API key; CSFloat is optional with your own free key.

**Try it:** Click Start with the default input: 3 items priced on 6 venues in 5.8 s for about $0.003 (run on October 21, 2026).

Default input: `compare` mode, three items. Real rows from that run, lowest ask per venue in USD (lowest in bold):

| Item | Skinport | DMarket | Waxpeer | Market.CSGO | LIS-SKINS | Steam | Spread | Best flip after fees |
|---|---|---|---|---|---|---|---|---|
| AK-47 | Redline (Field-Tested) | 25.29 | **24.68** | 26.60 | 26.81 | 26.35 | 32.55 | 31.9% | dmarket → marketcsgo, 3.2% |
| AWP | Asiimov (Field-Tested) | 101.91 | **92.00** | 104.45 | 104.15 | 100.36 | 126.39 | 37.4% | dmarket → marketcsgo, 7.5% |
| Fever Case | **0.51** | 0.80 | 0.58 | 0.58 | 0.57 | 0.77 | 56.9% | skinport → dmarket, 49.0% |

Each row also carries Skinport sales stats for 24h, 7d, 30d and 90d (for example AK-47 Redline FT: 72 sales in 7 days, median $25.93), DMarket's highest buy order and `instantFlip`, listing counts per venue and venue URLs. Switch to `market` or `gaps` mode to scan the whole CS2 market (30,000+ items) in one run.

**Pricing:** $0.90 per 1,000 items priced (primary event; $0.0009 per output row). Names that no venue lists come back with suggestions and are not charged; failed runs are not charged; platform usage included.

### More real examples (runs of October 13, 2026)

Input (compare mode):

```json
{
  "mode": "compare",
  "items": ["AK-47 | Redline (Field-Tested)", "AWP | Asiimov (Field-Tested)", "Fever Case", "★ Bayonet | Doppler (Minimal Wear)"],
  "includeTradeLocked": true
}
```

Lowest ask per venue, in USD:

| Item | Skinport | DMarket | Waxpeer | Market.CSGO | LIS-SKINS | Steam | Spread |
|---|---|---|---|---|---|---|---|
| AK-47 | Redline (Field-Tested) | 25.93 | **24.99** | 27.11 | 27.88 | 26.23 | 32.59 | 30.4% |
| AWP | Asiimov (Field-Tested) | 99.12 | **95.68** | 106.08 | 104.00 | 102.18 | 130.75 | 36.7% |
| Fever Case | 0.64 | 0.80 | **0.59** | **0.59** | **0.59** | 0.85 | 44.1% |
| ★ Bayonet | Doppler (Minimal Wear) | none tradable | **418.99** | 484.31 | 501.69 | none | 527.02 | 25.8% |

The first row as the actor returns it (shortened):

```json
{
  "marketHashName": "AK-47 | Redline (Field-Tested)",
  "currency": "USD",
  "referencePrice": 26.67,
  "lowestAsk": 24.99,
  "lowestAskVenue": "dmarket",
  "highestAsk": 32.59,
  "highestAskVenue": "steam",
  "askSpreadPercent": 30.41,
  "venuesWithPrice": 6,
  "prices": {"skinport": 25.93, "steam": 32.59, "dmarket": 24.99, "waxpeer": 27.11, "marketcsgo": 27.88, "lisskins": 26.23},
  "outlierVenues": [],
  "bestFlip": {"buyVenue": "dmarket", "buyPrice": 24.99, "sellVenue": "marketcsgo", "sellPrice": 27.88,
               "sellFeePercent": 5, "netProceeds": 26.49, "profit": 1.5, "profitPercent": 5.99},
  "instantFlip": {"buyVenue": "skinport", "buyPrice": 25.93, "sellVenue": "dmarket", "sellPrice": 24.6,
                  "sellFeePercent": 5, "netProceeds": 23.37, "profit": -2.56, "profitPercent": -9.87, "sellTo": "DMarket buy order"},
  "skinportLowestPrice": 25.93,
  "skinportQuantity": 555,
  "skinportSuggestedPrice": 30.68,
  "skinportSales24h": {"min": 24.38, "max": 44.86, "avg": 30.71, "median": 28.25, "volume": 10},
  "skinportSales7d": {"min": 23.26, "max": 168.22, "avg": 31.38, "median": 26.96, "volume": 95},
  "skinportSales30d": {"min": 18.89, "max": 2126.64, "avg": 38.49, "median": 27.36, "volume": 345},
  "skinportSales90d": {"min": 18.89, "max": 2126.64, "avg": 45.45, "median": 29.7, "volume": 960},
  "skinportTradeLockedLowestPrice": 22.83,
  "skinportTradeLockedQuantity": 64,
  "steamLowestPrice": 32.59,
  "dmarketLowestPrice": 24.99,
  "dmarketListings": 1037,
  "dmarketHighestBid": 24.6,
  "dmarketBids": 155,
  "waxpeerLowestPrice": 27.11,
  "waxpeerListings": 251,
  "marketcsgoLowestPrice": 27.88,
  "marketcsgoListings": 328,
  "lisskinsLowestPrice": 26.23,
  "lisskinsListings": 2389,
  "fetchedAt": "2026-10-13T01:44:31Z"
}
```

A misspelled name such as `AK-47 | Redline (Field Tested)` comes back with `"didYouMean": ["AK-47 | Redline (Field-Tested)", ...]` and is not charged.

#### Gap scanner example (same night, 01:45 UTC)

`{"mode": "gaps", "maxItems": 15}` checked 31,468 items and returned the 15 widest liquid gaps. Three of them:

| Item | Buy | Sell | Profit after fee | Skinport sales (7 days) |
|---|---|---|---|---|
| Glock-18 | Nuclear Garden (Field-Tested) | LIS-SKINS 1.53 | Skinport list at 2.49 (−8%) | 49.7% | 30 |
| Paris 2023 Anubis Souvenir Package | Skinport 1.84 | DMarket buy order 2.31, instant | 19.3% (instantFlip) | 38 |
| P250 | Cartel (Minimal Wear) | Skinport 9.73 | Market.CSGO list at 16.25 (−5%) | 58.7% | 5 |

`bestFlip` assumes you list at the other venue's current lowest ask and wait for a buyer. `instantFlip` sells straight into DMarket's highest buy order. See the limits below before trading on either.

### What you can do with it

- **Price checker and portfolio value**: price a list of items, or a whole inventory, on six venues at once.
- **Arbitrage and trade-up research**: find items that are cheaper on one marketplace than another after fees.
- **Market dashboards**: run on a schedule and track lowest asks, listings and Skinport sales volume over time.
- **Bots, Discord alerts, Google Sheets**: JSON, CSV or Excel over the Apify API, webhooks and integrations.

### Modes

| Mode | What it returns | Typical run |
|---|---|---|
| `compare` (default) | One row per item you list in `items`, priced on every venue | 3 items in about 6 s |
| `market` | Every item the venues list, filtered by name, price, listings and Skinport sales, sorted as you choose (default: most sold on Skinport in 7 days) | Whole market in about 9 s |
| `gaps` | The same universe ranked by best flip profit after fees, with liquidity and outlier guards on | About 8 s |

#### Main input fields

| Field | Default | Notes |
|---|---|---|
| `items` | 3 examples | Exact Steam market hash names, including the wear in brackets. Case is ignored. |
| `currency` | USD | 14 currencies. Skinport quotes it natively; USD venues are converted at that day's ECB rate. |
| `venues` | all six | Skinport, DMarket, Waxpeer, Market.CSGO, LIS-SKINS, Steam. |
| `csfloatApiKey` | empty | Free key from csfloat.com > Profile > Developer. Adds CSFloat lowest price, median of the 50 cheapest listings and cheapest float. |
| `includeSalesHistory` | true | Skinport completed sales for 24h, 7d, 30d and 90d. |
| `includeTradeLocked` | false | Also report Skinport listings still under Steam's 7-day trade hold, which sell cheaper. |
| `search`, `minPrice`, `maxPrice`, `minVenues`, `minListings`, `minSales7d` | | Filters for market and gaps modes. |
| `sortBy` | sales7d / flip | `flip`, `instantFlip`, `spread`, `sales7d`, `sales30d`, `listings`, `price`, `discount`. |
| `minProfitPercent` | empty | Gaps mode: only output flips above this profit. |
| `sellerFeePercent` | see below | Override any venue's seller fee for the flip math. |
| `maxPriceRatio` | 1.5 | Outlier guard: asks more than 1.5x away from the median of all venues are ignored in spreads and flips. |
| `minSellListings` | 5 | A venue must have at least this many listings to count as a place to sell. |

Default seller fees (October 2026, editable): Skinport 8%, Steam 13.04% (5% plus the 10% CS2 fee on top of the seller's price), CSFloat 2%, DMarket 5%, Waxpeer 6%, Market.CSGO 5%, LIS-SKINS 5%.

### Output fields

- **Summary**: `referencePrice` (median of the venues' lowest asks), `lowestAsk`, `lowestAskVenue`, `highestAsk`, `highestAskVenue`, `askSpreadPercent`, `venuesWithPrice`, `prices` (lowest ask per venue), `outlierVenues`, `bestFlip`, `instantFlip`.
- **Skinport**: lowest, median, mean and max listing price, suggested price, discount vs suggested, quantity, item URL, sales stats for 24h/7d/30d/90d, Doppler and Gamma Doppler phases in `skinportVersions`, optional trade-locked lowest price.
- **DMarket**: lowest ask, listings, highest buy order, number of buy orders, URL.
- **Waxpeer, Market.CSGO, LIS-SKINS**: lowest ask and listings (plus a LIS-SKINS URL).
- **Steam**: `steamLowestPrice`, the Steam Community Market lowest listing, plus a market URL.
- **CSFloat** (with key): lowest buy-now price, median of the 50 cheapest listings, cheapest listing's float value and URL.
- `notes`, `didYouMean`, `venuesUnavailable`, `fetchedAt`.

The dataset has three views: **Prices by venue**, **Price gaps and flips** and **Skinport detail**. A CSV link with nested fields flattened is in the run's Output tab.

### Pricing

Pay per event, and platform usage is included:

| Event | Price |
|---|---|
| Item priced (one output row) | **$0.90 per 1,000 items** ($0.0009 each) |
| Actor start | $0.00005 |

Pricing 100 items costs $0.09. Names that no venue lists are returned with suggestions and are not charged. Use **Max items** and the run's **maximum charge** setting to cap spend.

### Where the data comes from and accuracy

- **Skinport**: the official public API (`/v1/items` and `/v1/sales/history`). Skinport caches these for 5 minutes and allows 8 requests per 5 minutes per IP. The actor uses 2 or 3 requests per run and switches to a fresh Apify Proxy IP if it is rate-limited.
- **Waxpeer, Market.CSGO, LIS-SKINS**: each marketplace's public price export (one request per run each). These refresh every few minutes on the venue's side.
- **DMarket**: the public aggregated-prices endpoint (best offer and best buy order), 200 items per request.
- **Steam**: Steam blocks market requests from cloud servers (HTTP 429 from every Apify IP we tested), so `steamLowestPrice` comes from Waxpeer's Steam price feed. It matched live Steam exactly in our checks (AK-47 Redline FT $32.59, Fever Case $0.85), but a few rare items carry stale values. The outlier guard keeps those out of the gap math. Steam's 24-hour median and volume are not included.
- **CSFloat**: the official listings API with your key, one request per item (first 50 items by default, `csfloatMaxItems`). CSFloat rate-limits some shared cloud IPs ("too many requests from too many IPs"). If that happens, CSFloat is skipped after about 15 seconds with a warning, and every other venue is still delivered.
- Prices are for **tradable** items unless a field says trade-locked. Venues quote USD; other currencies use the ECB rate from Frankfurter.
- Every venue fails independently. If one is down, the run still finishes, affected rows list it in `venuesUnavailable`, and the status message says what happened.

### Limits, read before trading

- `bestFlip` compares lowest asks. Selling at another venue's lowest ask means listing there and waiting for a buyer, and the price can move. `instantFlip` (DMarket buy orders) is the only immediate sale.
- Some gaps persist for structural reasons. LIS-SKINS often lists below DMarket's buy orders (for example Prisma Case at 1.03 against a 1.53 bid on October 13, 2026). Moving money between venues has costs: DMarket and Waxpeer withdrawal fees, KYC, payout limits, and crypto or regional payment methods.
- Fees exclude deposit, withdrawal and payout fees, trade holds (7 days after most purchases) and float, pattern or sticker premiums. Doppler phases are merged on every venue except Skinport, which lists them separately in `skinportVersions`.
- Steam is a buy venue only by default: Steam pays sellers in wallet funds that cannot be withdrawn. Turn on `steamAsSellVenue` to change that.
- Thin markets are noisy. Gaps mode by default requires a price of at least 1, at least 5 Skinport sales in 7 days, at least 2 venues, and at least 5 listings on the sell venue.
- This actor reports public prices. It does not buy, sell or log in anywhere.

### FAQ

**Do I need any API keys?** No. Six venues work without keys. CSFloat is optional and its key is free.

**What name format do I use?** The Steam market hash name, exactly as on the Steam Community Market, e.g. `StatTrak™ AK-47 | Redline (Field-Tested)`, `★ Karambit | Doppler (Factory New)`, `Fever Case`, `Sticker | Natus Vincere (Holo) | Katowice 2014`.

**Can I price my whole inventory?** Yes. Put all names in `items` (thousands are fine). The bulk venues cost the same for 1 item or 10,000.

**How fresh are the prices?** Fetched at run time (`fetchedAt`). Venues cache their exports for a few minutes.

**Is Buff163 included?** No. Buff163 needs a logged-in Chinese account, and this actor only uses public endpoints.

**Can I schedule it?** Yes. Create a task with your input and add an Apify schedule, for example hourly. Each run is a fresh snapshot you can append to a sheet or database.

### Changelog

- **0.1 (October 13, 2026)**: first release. Compare, market and gaps modes; Skinport, DMarket, Waxpeer, Market.CSGO, LIS-SKINS, Steam (reference) and CSFloat (with key); outlier and liquidity guards; 14 currencies.

# Actor input Schema

## `mode` (type: `string`):

compare: one row per item in 'Items', priced on every venue, with Skinport sales history and the best cross-venue flip. market: every CS2 item the venues list, filtered and sorted (default: most sold on Skinport in 7 days). gaps: same universe ranked by the best buy-here-sell-there profit after fees (defaults: price >= 1, sold >= 5 times on Skinport in 7 days, listed on >= 2 venues).

## `items` (type: `array`):

Exact Steam market hash names, one per line, with the wear in brackets, e.g. AK-47 | Redline (Field-Tested). StatTrak™ and ★ prefixes must match Steam. Case is ignored and near-misses get 'didYouMean' suggestions.

## `currency` (type: `string`):

Skinport quotes this currency natively. The other venues quote USD and are converted with that day's ECB rate (Frankfurter API).

## `venues` (type: `array`):

Marketplaces to include. All of these work without an API key. CSFloat is added automatically when you enter a CSFloat API key below.

## `csfloatApiKey` (type: `string`):

CSFloat's listings API needs a free key (csfloat.com > Profile > Developer). With a key, rows also get the CSFloat lowest buy-now price, the median of the 50 cheapest listings and the cheapest listing's float value.

## `csfloatMaxItems` (type: `integer`):

CSFloat needs one request per item, so it is only checked for the first N rows.

## `includeSalesHistory` (type: `boolean`):

Add Skinport completed-sale stats (min, max, avg, median, volume) for the last 24 hours, 7, 30 and 90 days.

## `includeTradeLocked` (type: `boolean`):

Also report the lowest price and count of Skinport listings still under Steam's 7-day trade hold. They usually sell below tradable listings. All other prices are for tradable items.

## `search` (type: `array`):

Keep items whose name contains all words of any line (case-insensitive), e.g. 'case', 'karambit doppler', 'stattrak ak-47'. Empty keeps everything.

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

Skip items whose reference price (median of the venues' lowest asks) is below this. Gaps mode uses 1 when empty.

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

Skip items whose reference price is above this.

## `minVenues` (type: `integer`):

Skip items listed on fewer venues. Gaps mode uses 2 when empty; market mode 1.

## `minListings` (type: `integer`):

Skip items with fewer listings summed across Skinport, Waxpeer, Market.CSGO and LIS-SKINS (and DMarket after enrichment).

## `minSales7d` (type: `integer`):

Skip items sold fewer times on Skinport in the last 7 days, a liquidity check. Gaps mode uses 5 when empty.

## `minProfitPercent` (type: `number`):

Only output items whose best flip or instant flip nets at least this percent after the selling venue's fee. Empty outputs the top items whatever the profit.

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

Ranking for market and gaps modes. Empty: gaps sorts by flip profit, market by Skinport 7-day sales.

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

Rows to output. Market mode default 100, gaps mode 50. In compare mode, only the first N items of your list are priced.

## `sellerFeePercent` (type: `object`):

Percent of the sale price each venue keeps when you sell, used for bestFlip and instantFlip. Defaults (October 2026): Skinport 8, Steam 13.04 (5% + 10% CS2 fee on top of the seller price), CSFloat 2, DMarket 5, Waxpeer 6, Market.CSGO 5, LIS-SKINS 5. Override any of them, e.g. {"dmarket": 3}.

## `steamAsSellVenue` (type: `boolean`):

Steam pays sellers in Steam Wallet funds, which cannot be withdrawn, so by default Steam is only a buy venue in bestFlip. Turn on to also consider selling on Steam (useful if you want wallet funds).

## `maxPriceRatio` (type: `number`):

A venue's lowest ask more than this many times (default 1.5) above or below the median of all venues is treated as a troll listing or stale feed and left out of lowestAsk, spread and flips (it still shows in that venue's own field and in outlierVenues). With only two venues this far apart, no flip is computed.

## `minSellListings` (type: `integer`):

A venue only counts as the sell side of a flip if it has at least this many listings of the item, so one overpriced listing on a thin venue does not look like profit. Steam has no listing count and is never a sell venue unless you allow it above.

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

Requests go direct first. The proxy is only used to switch IP when a venue rate-limits (Skinport allows 8 requests per 5 minutes per IP). Datacenter proxy is enough.

## Actor input object example

```json
{
  "mode": "compare",
  "items": [
    "AK-47 | Redline (Field-Tested)",
    "AWP | Asiimov (Field-Tested)",
    "Fever Case"
  ],
  "currency": "USD",
  "venues": [
    "skinport",
    "dmarket",
    "waxpeer",
    "marketcsgo",
    "lisskins",
    "steam"
  ],
  "csfloatMaxItems": 50,
  "includeSalesHistory": true,
  "includeTradeLocked": false,
  "sellerFeePercent": {
    "skinport": 8,
    "steam": 13.04,
    "csfloat": 2,
    "dmarket": 5,
    "waxpeer": 6,
    "marketcsgo": 5,
    "lisskins": 5
  },
  "steamAsSellVenue": false,
  "maxPriceRatio": 1.5,
  "minSellListings": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `results` (type: `string`):

No description

## `csv` (type: `string`):

No description

## `flips` (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 = {
    "mode": "compare",
    "items": [
        "AK-47 | Redline (Field-Tested)",
        "AWP | Asiimov (Field-Tested)",
        "Fever Case"
    ],
    "venues": [
        "skinport",
        "dmarket",
        "waxpeer",
        "marketcsgo",
        "lisskins",
        "steam"
    ],
    "sellerFeePercent": {
        "skinport": 8,
        "steam": 13.04,
        "csfloat": 2,
        "dmarket": 5,
        "waxpeer": 6,
        "marketcsgo": 5,
        "lisskins": 5
    },
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("varnmill/cs2-skin-prices").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 = {
    "mode": "compare",
    "items": [
        "AK-47 | Redline (Field-Tested)",
        "AWP | Asiimov (Field-Tested)",
        "Fever Case",
    ],
    "venues": [
        "skinport",
        "dmarket",
        "waxpeer",
        "marketcsgo",
        "lisskins",
        "steam",
    ],
    "sellerFeePercent": {
        "skinport": 8,
        "steam": 13.04,
        "csfloat": 2,
        "dmarket": 5,
        "waxpeer": 6,
        "marketcsgo": 5,
        "lisskins": 5,
    },
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("varnmill/cs2-skin-prices").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "mode": "compare",
  "items": [
    "AK-47 | Redline (Field-Tested)",
    "AWP | Asiimov (Field-Tested)",
    "Fever Case"
  ],
  "venues": [
    "skinport",
    "dmarket",
    "waxpeer",
    "marketcsgo",
    "lisskins",
    "steam"
  ],
  "sellerFeePercent": {
    "skinport": 8,
    "steam": 13.04,
    "csfloat": 2,
    "dmarket": 5,
    "waxpeer": 6,
    "marketcsgo": 5,
    "lisskins": 5
  },
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call varnmill/cs2-skin-prices --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,varnmill/cs2-skin-prices"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

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