SteamAnalyst APIcsgo.steamanalyst.com ↗
Access CS2 skin prices, 30-day price history, market trends, weapon cases, and collections from SteamAnalyst via a structured REST API.
What is the SteamAnalyst API?
This API exposes 9 endpoints covering CS2 skin data from SteamAnalyst, including real-time pricing, 30-day historical price trends, market-wide statistics, and case contents. The get_skin_price_history endpoint returns a date-indexed array of prices in cents USD, while get_market_trends_overview surfaces aggregate counts of trending-up, trending-down, and stable items across the entire CS2 skin market.
curl -X GET 'https://api.parse.bot/scraper/5282c6cf-4984-4dd8-a8ee-dd953ccb9dfe/search_skins?page=1&query=ak-47' \ -H 'X-API-Key: $PARSE_API_KEY'
Typed, relational, agent-ready
A generated client with real types, enums, and the links between objects — the structure a flat JSON response can't carry. Autocompletes in your editor and reads cleanly to coding agents.
- Fully typed · autocompletes
- Objects link to objects
- Typed errors & pagination
Typed Python client. Set up the SDK in your uv project, then pull this API’s typed client:
uv add parse-sdk uv run parse init uv run parse add --marketplace csgo-steamanalyst-com-api
uv run parse add --marketplace pulls a pinned snapshot of this canonical API — it won’t change underneath you. To customize it, subscribe and swap to your own copy.
"""
SteamAnalyst CS2 Skins API — Usage Example
Search skins, check pricing across marketplaces, browse weapon catalogs,
and explore market trends.
"""
from parse_apis.steamanalyst_cs2_skins_api import (
SteamAnalyst, Wear, SkinNotFound
)
analyst = SteamAnalyst()
# Search for AK-47 skins across the market
for skin in analyst.skins.search(query="ak-47", limit=3):
print(skin.market_name, skin.price_min, skin.collection)
# Drill into a specific skin's detail and price history
ak = analyst.skin(canonical="ak-47-asiimov")
detail = ak.detail(wear=Wear.FIELD_TESTED)
print(detail.product, detail.skin_metadata)
for point in ak.price_history.list(wear=Wear.FIELD_TESTED, limit=5):
print(point.date, point.price)
# Browse all skins for a weapon
awp = analyst.weapon(name="awp")
for weapon_skin in awp.skins(limit=3):
print(weapon_skin.position, weapon_skin.item)
# Market overview: stats and per-weapon trends
overview = analyst.marketoverviews.get()
print(overview.stats.tracked_items, overview.stats.total_volume)
# Top gainers by trend percentage
for trend in analyst.weapontrends.top_gainers(limit=3):
print(trend.name, trend.trend, trend.avg_price)
# Get a weapon case and its contents
try:
case = analyst.cases.get(slug="revolution-case")
print(case.case_name, case.number_of_items)
for item in case.contents.list(limit=3):
print(item.position, item.name, item.url)
except SkinNotFound as exc:
print(f"Case not found: {exc.slug}")
print("exercised: skins.search / skin.detail / price_history.list / weapon.skins / marketoverviews.get / weapontrends.top_gainers / cases.get / contents.list")
Full-text search across all CS2 skins by keyword. Matches weapon name, skin name, and collection. Returns paginated results sorted by price descending, with pricing metadata and float ranges for each matching item. Each result includes a canonical slug suitable for the skin detail endpoint.
| Param | Type | Description |
|---|---|---|
| page | integer | Page number for pagination |
| queryrequired | string | Search keyword (e.g. 'ak-47', 'dragon lore', 'asiimov') |
{
"type": "object",
"fields": {
"page": "integer current page number",
"total": "integer total number of matching results",
"results": "array of skin objects with id, market_name, canonical slug, type, model, quality, price info, collection, and float range",
"totalPages": "integer total number of pages"
},
"sample": {
"data": {
"page": 1,
"total": 67,
"results": [
{
"id": 307162902,
"img": "https://community.akamai.steamstatic.com/economy/image/...",
"name": "Wild Lotus",
"type": "Rifle",
"model": "AK-47",
"phase": null,
"price": null,
"quality": "Covert",
"souvenir": "n",
"stattrak": "n",
"canonical": "ak-47-wild-lotus",
"max_float": 0.9999999999,
"min_float": 0,
"price_max": 17631.55,
"price_min": 3927.37,
"collection": "The St. Marc Collection",
"market_name": "AK-47 | Wild Lotus (Factory New)",
"market_name_wo_ext": "AK-47 | Wild Lotus",
"markets_based_price": 1763155,
"has_stattrak_variant": false
}
],
"totalPages": 3
},
"status": "success"
}
}About the SteamAnalyst API
Skin Search and Detail
The search_skins endpoint accepts a keyword query — such as ak-47, dragon lore, or asiimov — and returns paginated results with each skin's id, market_name, canonical slug, type, model, quality, price info, collection, and float range. The get_skin_detail endpoint takes a slug and an optional wear parameter (one of factory-new, minimal-wear, field-tested, well-worn, battle-scarred) and returns schema.org Product data including name, description, image, SKU, category, and an AggregateOffer object with lowPrice and highPrice fields, plus any additional skin_metadata available from the page.
Pricing and History
get_skin_market_prices returns the same AggregateOffer pricing structure — lowPrice, highPrice, and offerCount — for a given skin slug and wear tier, useful for quickly checking current market spread without the full detail payload. get_skin_price_history returns a 30-day sparkline as an array of { date, price } objects where price is an integer in cents USD, making it straightforward to plot trends or compute percentage change over the period.
Market Trends and Weapons
get_market_trends_overview returns top-level market stats (tracked_items, trending_up, trending_down, stable, total_volume) alongside a per-weapon breakdown with avg_price, volume, total_value, and a trend percentage. get_top_gainers filters this data by highest trend percentage and accepts a limit parameter. get_weapon_skins lists all skins for a given weapon slug with pagination, returning name, URL, image, and current price for each item.
Collections and Cases
list_collections returns every CS2 skin collection as a set of { href, label } objects. get_case_detail accepts a case slug (e.g., revolution-case, kilowatt-case) and returns the case name, total item count, an ordered list of skin contents with position, URL, and name, plus a FAQ array with structured question-and-answer pairs about that case.
The SteamAnalyst API is a managed, monitored endpoint for csgo.steamanalyst.com — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when csgo.steamanalyst.com changes and a check fails, the API is automatically queued for repair and re-verified. It is built to keep working as the site underneath it changes.
This isn't an official csgo.steamanalyst.com API — it's an independent, maintained REST wrapper over public data. Where the source has no official API (or only a limited one), Parse gives you a stable contract over a source that never promised one, and keeps it current. Need a new endpoint or field? You can revise it yourself in plain English and the agent rebuilds it against the live site in minutes — contributing the change back to the shared API is free.
Will this API break when the source site changes?+
Is this an official API from the source site?+
Can I fix or extend this API myself if I need a new endpoint or field?+
What happens if I call an endpoint that has an issue?+
- Track 30-day price movements for specific skins using
get_skin_price_historyto time buy/sell decisions. - Build a CS2 trading dashboard showing top-gaining weapons by trend percentage via
get_top_gainers. - Compare low and high market prices for each wear tier of a skin using
get_skin_market_prices. - Index all skins in a weapon case and their contents using
get_case_detailfor inventory tools. - Enumerate all CS2 collections using
list_collectionsto populate a browsable catalog. - Aggregate per-weapon average prices and trading volumes from
get_market_trends_overviewfor market analysis. - Paginate all skins for a specific weapon like
awporak-47usingget_weapon_skinsto build comparison tables.
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 100 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
One credit = one API call regardless of which marketplace API you call. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.
Does SteamAnalyst have an official developer API?+
What does `get_skin_price_history` return and how far back does it go?+
get_skin_price_history returns up to 30 days of daily price data as an array of objects, each with a date field in YYYY-MM-DD format and a price field expressed as an integer in cents USD. The history window is fixed at 30 days; longer historical ranges are not currently available through this endpoint.Does the API expose StatTrak or Souvenir skin variants separately?+
get_skin_detail, get_skin_market_prices, and get_skin_price_history. You can fork this API on Parse and revise it to add StatTrak/Souvenir variant support.Does `get_skin_detail` include individual marketplace listings or just aggregate pricing?+
get_skin_detail returns an AggregateOffer object with lowPrice, highPrice, and offerCount — it reflects the market-wide price range, not individual seller listings. Per-listing data (individual seller prices, conditions, or listing timestamps) is not currently exposed. You can fork this API on Parse and revise it to add individual listing detail endpoints.Is float value data available for individual skins?+
search_skins returns the float range (minimum and maximum float) for each skin in its result set as part of the skin object. Exact float values for specific in-market listings are not currently returned by any endpoint. You can fork this API on Parse and revise it to add per-listing float inspection.