---
title: "Thin markets and price expiry — JustTCG API"
description: "Why rarely traded cards can carry stale or surprising prices, when a price expires after 14 days without a market report (including collapsed prices), how implausible sales are kept out of v2 periods, and the v1 and v2 fields (priceStatus, lastKnownPrice, price_status, last_price) that tell you how far to trust a price."
url: https://justtcg.com/docs/thin-markets
markdown_url: https://justtcg.com/docs/thin-markets.md
---

# Thin markets and price expiry

Some cards rarely sell. This page explains what that does to a price, when a price expires, and which fields tell you how far to trust it. It applies to v1 and v2 alike; only the field names differ.

**TL;DR:** A price that goes **14 days** without a market report expires if it is $100 or more, or if it has collapsed to under 10% of the variant's own recent prices. Its `price` becomes `null`, its status says `expired`, and the value that expired is kept in `lastKnownPrice` (v1) or `last_price` (v2). A v2 graded price expires the same way when its last sale is more than **90 days** old. Price history and statistics are never changed.

## Why thin markets look odd

A raw variant's `price` is the last price the market recorded for that condition, and a graded one is picked from the slab's recent sales ([below](https://justtcg.com/docs/thin-markets#expiry)). It is never smoothed or clamped, and we never replace it with a number of our own: a price we cannot stand behind becomes `null`, and the value is kept alongside it. For cards that rarely trade raw, such as vintage chase cards, ultra-rare promos, and most graded grades, a single condition can go months between sales. One mislisted sale can therefore set the price for a long time, and conditions can look inverted (Moderately Played above Near Mint).

## How a price expires

Marketplaces eventually correct or age out bad sales and stop reporting a price for that condition altogether. When that happens we do not keep serving the last value forever: a variant priced at $100 or more that goes 14 days without a reported price expires to a `null` price until a new sale is recorded. Expiry has been in effect since 2026-10-01. A second rule covers [collapsed prices](https://justtcg.com/docs/thin-markets#collapsed) at any price level.

Expiry changes `price` and nothing else. The variant reports an `expired` status and carries the value that expired. Its last-observed timestamp, price history and window statistics are left untouched. When a new sale arrives, the status returns to `current`.

**Graded variants (v2) get a longer window.** A graded price comes from the slab's own sales, and a slab that trades a few times a year is normal, so 14 days would expire almost every slab. Instead, a graded price expires when its last sale is more than **90 days** old, at any price level, grade or grading company. Past that, one unadjusted sale says more about when it happened than about today's market, and we do not adjust or model prices to stretch it. It expires the same way: `price` becomes `null`, `price_status` is `expired`, `last_price` keeps the sale, and `updated_at` stays the time of that sale. Graded browse and search list expired slabs after priced ones.

**How a graded price is set.** A current graded price is the weighted median of the slab's sales in the last 90 days, with each sale counting half as much for every 14 days of age. It is always one of those actual sale prices, never an average. A fresh sale weighs more than older ones, so the price is usually the slab's newest sale, and a single new outlier can still set it; the median only holds out against an outlier once a slab has three or more sales close together in time. Most slabs today have one sale in the window and are priced at that sale.

Every graded market also carries `last_sale_at`, the time of the slab's most recent sale, and `price_expires_at`, when that sale ages out (in the past once it has). Both are Unix timestamps in seconds, and both are `null` on raw variants and on graded variants that have never sold. `periods.90d.sales_count` says how many sales a current price rests on; for most slabs it is 1.

## Collapsed prices and implausible sales

Occasionally a market report collapses for no reason in the card itself: a $1,400 promo reports $0.40 for a day or two and then stops being reported at all. A collapsed value like that is often never corrected, so the $100 floor alone would let it stand indefinitely.

**Collapsed prices expire too.** A price that goes 14 days without a market report also expires when it is below **10%** of the median of the variant's own prices over the 180 days before it changed to that value (at least five observations are required). It expires exactly like a high-value price: `price` becomes `null`, the status says `expired`, the collapsed value is kept in `lastKnownPrice` / `last_price`, and nothing else changes. It stays expired until the market reports the variant again. A price the market is still reporting is never expired, however low it is. The rule is applied when each set is next processed, so a matching price can take a day or two past the 14 days to expire.

**Implausible sales are left out of v2 periods.** The statistics in `markets[].periods` are computed from individual sales. A single sale priced below 10% or above 10 times the variant's 90-day market average (when that average is at least $5) is held out of every window, the same way a refunded sale is. A sale that is held out is kept on record for review. If a card has no other sales in a window, that window is omitted rather than built from the one implausible sale. Graded and non-USD sales are not screened.

Neither rule smooths or adjusts a price. Each one only decides whether a reported value is served. When one is not, you see `null` (or a missing window) instead of a number, and the reported value is kept.

## The fields, in v1 and v2

| Meaning | v1 | v2 |
| --- | --- | --- |
| Current price (null when expired or never priced) | `price` | `markets[].price` |
| Why the price is what it is: current, expired or unpriced | `priceStatus` | `markets[].price_status` |
| The value that expired (null unless expired) | `lastKnownPrice` | `markets[].last_price` |
| When the price was last observed | `lastUpdated` | `markets[].updated_at` |
| Activity in the last 90 days: price changes, and in v2 also sales | `priceChangesCount90d` | `markets[].periods.90d.changes_count, .sales_count` |

The status takes one of three values. `current`: a market report is in effect. `expired`: the last price aged out, so the price is `null` and the last observed value is carried alongside it. `unpriced`: this condition has never had a price. Full field references: [Variant object (v1)](https://justtcg.com/docs/schema/variant#v1) and [Variant object (v2)](https://justtcg.com/docs/schema/variant#v2-markets).

```json
{
  "id": "one-piece-card-game-…-secret-rare_near-mint_foil",
  "price": null,
  "priceStatus": "expired",
  "lastKnownPrice": 4400.43,
  "lastUpdated": 1782360444
}
```

## Incremental syncs

An expiry counts as a price change, so a sync that uses `updated_after` receives the expired variant once, with its `null` price. If your sync assumes every returned price is non-null, handle `null` or branch on the status field. In v2 a graded variant counts as changed when we record a new sale for it (sales can reach us days after they happen, so this is when we recorded it, not when it sold), when a sale moves out of one of its `periods` windows, and when its price expires. Each of those returns it from `updated_after`, within about 10 minutes. To expire graded rows without waiting for the next sync, compare `price_expires_at` with the current time. Outside of `updated_after`, a card whose every variant is `null` is omitted from browse responses unless you pass `include_null_prices=true`.

## Judging confidence yourself

The response carries what you need:

-   Treat a variant with **0 price changes in 90 days**, or a last-observed time **older than 14 days**, as low confidence.
-   Treat a condition priced **above the next-better condition** of the same card as a flag, and clamp it client-side if your use case needs a strict ladder.

For the vast majority of the catalog these checks never fire. JustTCG is a sales-data API, not a valuation service: when there is no market activity, we would rather show you that than invent a number.
