# GET /v1/liquidity/items

Daily liquidity buckets and estimated sale times for every item.

Returns the latest liquidity bucket and estimated sale time for every item.

Liquidity is recomputed daily from sale volume and traded value over rolling 30- and 90-day windows, weighted toward recent activity. Variants are scored independently from their base item.

## Access

Requires a Scale or Enterprise API key.

## Liquidity buckets

| Bucket | Meaning |
| --- | --- |
| `unknown` | Too few recent sales to classify. |
| `extremely_illiquid` | Almost no sales. |
| `very_illiquid` | Very low sale volume. |
| `illiquid` | Low sale volume. |
| `moderate` | Moderate sale volume. |
| `liquid` | Consistent sale volume. |
| `very_liquid` | High sale volume. |
| `extremely_liquid` | Very high sale volume; among the most-traded items. |

## Variants

Supported Doppler, Gamma Doppler, and Case Hardened variants are returned under the base item in `variants`. Variant maps are keyed by display name, such as `Phase 1`, `Ruby`, or `Tier 1`. In a variant object, `market_hash_name` is the base item name, `name` is the full variant name, and `version` is the stable code.

## Request

`GET https://api.cs2.sh/v1/liquidity/items`

**curl**

```bash
curl https://api.cs2.sh/v1/liquidity/items \
  -H "Authorization: Bearer <<YOUR_API_KEY>>" \
  -H "Accept-Encoding: gzip" --compressed
```

**Python**

```python
import requests

headers = {
    "Authorization": "Bearer <<YOUR_API_KEY>>",
    "Accept-Encoding": "gzip",
}

response = requests.get(
    "https://api.cs2.sh/v1/liquidity/items",
    headers=headers,
)

response.raise_for_status()
data = response.json()
```

**Node**

```javascript
const headers = {
  "Authorization": "Bearer <<YOUR_API_KEY>>",
  "Accept-Encoding": "gzip",
};

const response = await fetch("https://api.cs2.sh/v1/liquidity/items", { headers });

if (!response.ok) throw new Error(`HTTP ${response.status}`);
const data = await response.json();
```

**Go**

```go
package main

import (
    "compress/gzip"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
)

func main() {
    req, _ := http.NewRequest("GET", "https://api.cs2.sh/v1/liquidity/items", nil)
    req.Header.Set("Authorization", "Bearer <<YOUR_API_KEY>>")
    req.Header.Set("Accept-Encoding", "gzip")

    resp, err := http.DefaultClient.Do(req)
    if err != nil { panic(err) }
    defer resp.Body.Close()

    if resp.StatusCode < 200 || resp.StatusCode >= 300 {
        body, _ := io.ReadAll(resp.Body)
        panic(fmt.Sprintf("HTTP %d: %s", resp.StatusCode, body))
    }

    var reader io.Reader = resp.Body
    if resp.Header.Get("Content-Encoding") == "gzip" {
        gz, err := gzip.NewReader(resp.Body)
        if err != nil { panic(err) }
        defer gz.Close()
        reader = gz
    }

    var data any
    if err := json.NewDecoder(reader).Decode(&data); err != nil { panic(err) }
    fmt.Printf("%#v\n", data)
}
```

**R**

```r
library(httr2)

resp <- request("https://api.cs2.sh/v1/liquidity/items") |>
  req_headers(
    Authorization = "Bearer <<YOUR_API_KEY>>",
    `Accept-Encoding` = "gzip"
  ) |>
  req_perform()

data <- resp_body_json(resp)
```

## Response

```json
{
  "response_time": "2026-07-26T00:00:29.508Z",
  "run_date": "2026-07-26",
  "items": {
    "USP-S | Printstream (Factory New)": {
      "market_hash_name": "USP-S | Printstream (Factory New)",
      "liquidity": "extremely_liquid",
      "estimated_sale_time": "1 - 2 hours"
    }
  }
}
```

## Response fields

[ItemLiquidityGetResponse](/docs/objects#itemliquiditygetresponse) fields:

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `response_time` | `string (date-time)` | Yes | When the snapshot was computed. |
| `run_date` | `string (date)` | Yes | UTC date for the daily computation. |
| `items` | [`Record<string, ItemLiquidityItem>`](/docs/objects#itemliquidityitem) | Yes | Map of `market_hash_name` to item liquidity data. |

## Item data

| Field | Description |
| --- | --- |
| `items.<name>.liquidity` | Liquidity bucket, from `extremely_illiquid` to `extremely_liquid`. |
| `items.<name>.estimated_sale_time` | Estimated sale time range, assuming a competitive listing price. |
| `items.<name>.variants` | Per-variant liquidity entries, scored independently. |

- `market_hash_name`, `liquidity`, and `estimated_sale_time` are present on returned items.
- `variants` appears only for items with variant liquidity data.

Full schema: [ItemLiquidityItem](/docs/objects#itemliquidityitem).

### ItemLiquidityItem

Item liquidity bucket and estimated sale time for a single item.

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `market_hash_name` | `string` | Yes | Steam market hash name. |
| `liquidity` | `string` | No | Allowed: `unknown`, `extremely_illiquid`, `very_illiquid`, `illiquid`, `moderate`, `liquid`, `very_liquid`, `extremely_liquid`. Recomputed item liquidity bucket. |
| `estimated_sale_time` | `string` | No | Allowed: `under 1 hour`, `1 - 2 hours`, `2 - 6 hours`, `6 - 12 hours`, `12 - 24 hours`, `1 - 2 days`, `2 - 3 days`, `3 - 4 days`, `4 - 5 days`, `5 - 7 days`, `7 - 10 days`, `10 - 14 days`, `2 - 3 weeks`, `3 - 4 weeks`, `1 - 1.5 months`, `1.5 - 2 months`, `2+ months`, `unknown`. 80th-percentile estimated time for a competitively priced listing to sell. |
| `variants` | `Record<string, object>` | No | Per-variant item liquidity keyed by display name. |

## Errors

`503 service_unavailable` means the current liquidity snapshot is not ready. See [Request errors](/docs/using-the-api#request-errors) for shared errors.