---
title: "Get Regimes"
method: GET
path: "/api/v1/regimes"
tags: ["Regimes"]
---

# Get Regimes

`GET /api/v1/regimes`

## Request

- Base URL: `https://cryptodataapi.com`
- URL: `https://cryptodataapi.com/api/v1/regimes`
- Auth: API key in header `X-API-Key`

The 10-state long-horizon regime model + the current detected regime.

``regimes`` is the stable taxonomy (id, machine ``regime`` id, display name,
description, typical duration and directional bias). ``current`` is the live
classification with a ``rationale``, the inspectable ``signals`` that drove
it, and — where applicable — an internal ``stage`` (Distribution) or
``euphoria_score`` (Speculative Euphoria).

**Committed vs live.** ``current.regime``/``id``/``name``/``rationale`` are the
COMMITTED regime: an anti-churn dwell gate holds it until a new candidate is
the raw classification for ``pending.needed`` consecutive refreshes. But
``signals`` are always read fresh, so mid-turn they can stop supporting the
committed regime — that is expected, not stale data. ``current.raw`` gives the
live ungated classification and ``raw.matches_committed`` tells you the two
disagree; ``current.pending`` shows how far the successor has confirmed.

**Stability.** ``pending`` is null whenever the live read already agrees with
the committed regime — correct, but it means a consumer watching for a turn
sees a field that blinks in and out. ``current.stability`` is always present
and always numeric: ``raw_agreement`` decays as conditions drift,
``confirmations_against``/``needed`` track a successor, and ``locked_for_s``
is the HARD number — how long the dwell floor mechanically guarantees the
committed regime survives. ``current.thresholds`` gives the distance from
every numeric cutoff in the cascade to flipping, so hysteresis can be built
on published boundaries instead of guesses.

``typical_duration`` describes the real-world cycle phase, NOT a guaranteed
dwell — but the dwell floor is now SCALED to it: a "Weeks-Months" state
(#2/#4/#6/#8) must be held 48h before anything may replace it, "Weeks" 24h,
"Days-Weeks" 12h, and #1 Structural Shock only 2h because it is an emergency
override. Read the live value from ``stability.dwell_floor_s``.

``/regimes/history`` returns the committed transition sequence.

## Response `200`

Successful Response

- RegimesResponse: `/api/v1/regimes` — current detection plus the full taxonomy.
  - `current` CurrentRegime, required: The single regime the market is currently classified into.
    - `regime` string, nullable: Machine id, null on cold start
    - `id` integer, nullable
    - `anchor` string, nullable
    - `name` string, nullable
    - `rationale` string, nullable: Why this regime was selected
    - `stage` string, nullable: Sub-stage for Distribution (early_distribution|active_deleveraging) and Speculative Euphoria (alt_expansion|blow_off)
    - `stage_label` string, nullable: Human label for the sub-stage
    - `euphoria_score` integer, nullable: 0-100 froth gauge, present only for Speculative Euphoria
    - `signals` object: The classifier inputs (health scores, condition, BTC dominance, volatility / meme / security overlays, OI, liquidations) — transparency. ALWAYS LIVE: these are read at `as_of`, whereas regime/id/name/rationale describe the COMMITTED regime, which the dwell gate holds until a new candidate confirms. Compare against `raw` to see the two diverge.
    - `raw` RawClassification: What the cascade classifies RIGHT NOW, before the anti-churn dwell gate. The published regime is the COMMITTED one, which by design lags the live inputs — so ``signals`` can stop meeting the committed regime's entry condition while that regime is still served. Without this block that reads as contradictory data: a consumer sees ``rationale`` saying "a security shock is active" next to a ``security_stress`` below the trigger, with no way to tell the difference between "stale by design" and "broken". ``matches_committed`` false is normal and expected — it means a turn is being evaluated; read ``pending.count``/``needed`` for how far along it is.
      - `anchor` string, nullable
      - `regime` string, nullable
      - `name` string, nullable
      - `id` integer, nullable
      - `matches_committed` boolean, required: False when the live cascade disagrees with the committed regime
    - `as_of` string, nullable: ISO-8601 timestamp of the classification
    - `in_regime_since` string, nullable: ISO-8601 ts the current committed regime was ENTERED — advances only when the regime actually changes, so consumers can show how long it has held
    - `pending` PendingRegime: A candidate regime accumulating confirmations but not yet committed. Surfaced so a consumer can see a turn brewing before the committed regime actually changes (the anti-churn dwell gate requires ``needed`` consecutive samples before a switch).
      - `anchor` string, required
      - `regime` string, required
      - `name` string, required
      - `count` integer, required: Consecutive raw samples seen so far
      - `needed` integer, required: Consecutive samples required to commit
      - `since` string, nullable: ISO ts the candidate first appeared
      - `dwell_blocked_s` integer: Seconds still owed on the minimum-dwell floor. When >0 the candidate is FULLY confirmed (count >= needed) and is waiting only for the committed regime to satisfy its minimum hold — which is why count can sit above needed without committing.
    - `stability` RegimeStability: How firmly the committed regime is holding — always present, always numeric. ``pending`` is null exactly when the live cascade agrees with the committed regime, so a consumer polling for "is a turn brewing" gets a field that blinks in and out of existence and carries no signal on a hold. This block is the continuous companion: it is emitted on every response, candidate or not, so it can be differenced, thresholded, or fed to a risk sizer directly. ``locked_for_s`` is the only HARD number here — the minimum-dwell floor mechanically prevents any change for that long. The one exception is a Structural Shock override, which is exempt from the floor by design.
      - `score` number, required: 0-1 blend: 0.6 * raw_agreement + 0.4 * (1 - confirmation pressure). Excludes locked_for_s deliberately — a hard guarantee and a soft estimate do not belong in one number.
      - `raw_agreement` number, required: Fraction of the last raw_samples ungated classifications that matched the committed regime. Decays smoothly as conditions drift, well before any candidate confirms.
      - `raw_samples` integer, required: Samples currently in the window
      - `raw_window` integer, required: Window size in samples (~15 min each)
      - `confirmations_against` integer, required: Consecutive raw samples the current successor has accumulated (0 if none)
      - `confirmations_needed` integer, required: Consecutive samples a successor must accumulate — populated even with no candidate, so the pair is always interpretable
      - `candidate` string, nullable: Anchor of the pending successor, or null
      - `held_s` integer, nullable: Seconds the committed regime has been held
      - `dwell_floor_s` integer, required: This regime's own minimum-hold floor, scaled to its catalog typical_duration (see /regimes typical_duration)
      - `locked_for_s` integer, required: Seconds the committed regime is GUARANTEED to survive under the dwell floor. 0 means a confirmed successor could commit on the next refresh. Structural Shock can still pre-empt this.
    - `thresholds` RegimeThresholds: Distance to every numeric boundary in the cascade — the raw material for client-side hysteresis. The two CATEGORICAL inputs (``quant_label``, ``meme_season``) have no distance by construction; read them from ``signals``.
      - `nearest` ThresholdCheck: One numeric cutoff the classifier cascade tests, and how far it is from flipping.
        - `signal` string, required: Key in `signals` this check reads
        - `op` string, required: Comparison the cascade applies (>=, >, <=, <)
        - `cutoff` number, required
        - `value` number, nullable: Live value, or null if the feed is down
        - `holds` boolean, nullable: Whether the check passes right now
        - `distance` number, nullable: Absolute move required to cross the cutoff, in the signal's own units. Does NOT indicate direction of travel.
        - `gates` string, required: What crossing puts in play — a regime anchor, or condition:<state> for the health-score cutoffs that drive the cascade's dominant input
      - `checks` ThresholdCheck[], required
        - `signal` string, required: Key in `signals` this check reads
        - `op` string, required: Comparison the cascade applies (>=, >, <=, <)
        - `cutoff` number, required
        - `value` number, nullable: Live value, or null if the feed is down
        - `holds` boolean, nullable: Whether the check passes right now
        - `distance` number, nullable: Absolute move required to cross the cutoff, in the signal's own units. Does NOT indicate direction of travel.
        - `gates` string, required: What crossing puts in play — a regime anchor, or condition:<state> for the health-score cutoffs that drive the cascade's dominant input
  - `regimes` RegimeInfo[], required
    - `id` integer, required: Stable 1-10 ordinal, roughly cycle order
    - `regime` string, required: Machine id — the API contract (e.g. established_bear)
    - `anchor` string, required: Slug matching the /crypto-market-regimes web page section id
    - `name` string, required: Human display name
    - `description` string, required
    - `typical_duration` string, required
    - `directional_bias` string, required
  - `count` integer, required
  - `as_of` string, required

---

[API](https://skmtc.dev/cryptodataapi/apis/crypto-data-api.md) · [All operations](https://skmtc.dev/cryptodataapi/apis/crypto-data-api/llms.txt) · [OpenAPI document](https://skmtc.dev/cryptodataapi/apis/crypto-data-api/revisions/8628b754ca81?raw)