DEV Community: Gunnar Thorderson

Weekly Regime Recap: BEAR at 71% — March 26, 2026

Gunnar Thorderson — Sat, 25 Jul 2026 09:00:10 +0000

Weekly Regime Recap — March 26, 2026

Current Classification: BEAR (71% confidence)

The Regime classifier continues to read BEAR with 71% confidence. Here's the weekly breakdown.

Market Snapshot

Metric	Value
BTC	$69,404
ETH	$2,074
Fear & Greed	10 (Extreme Fear)
BTC Dominance	56.5%
Regime	BEAR at 71%

Signal Breakdown

Bullish signals: 1
Bearish signals: 3
Neutral signals: 2

Data Moat Update

6,802 market snapshots collected
68 regime transitions tracked
25 days of continuous monitoring

What This Means for Traders

Bear regime = capital preservation mode. Reduce long exposure to 10-15% of normal. Don't try to catch the bottom. The regime flip from bear to chop is the first signal to watch for.

At 10 Fear & Greed (Extreme Fear), sentiment is extremely negative. Historically, extreme fear persists during bear markets — it's a necessary condition for a bottom but not sufficient on its own.

Track This Live

curl https://getregime.com/api/v1/market/regime

Free API, no auth needed. Full docs | Pricing

Try Regime Intelligence

Regime is a real-time crypto market regime detection API. One endpoint tells you if the market is bull, bear, or chop — so your bot only trades when conditions match your strategy.

Free API access → | See pricing → | API docs →

Why Your Crypto Trading Bot Loses Money (And How to Fix It)

Gunnar Thorderson — Fri, 24 Jul 2026 09:00:15 +0000

Why Your Crypto Trading Bot Loses Money

You've backtested your strategy. It looked amazing on historical data. You went live and it started bleeding money. This happens to almost every crypto bot developer, and the reason is simpler than you think.

The #1 Killer: Regime Blindness

Your bot doesn't know what kind of market it's in. It trades the same way whether Bitcoin is in a raging bull run or a grinding bear market.

This is like driving the same speed on a highway and in a school zone. The vehicle works fine — the problem is context awareness.

The Data

We backtested multiple strategies across 302K candles (March 2023 to March 2026):

Strategy	Bull Market Return	Bear Market Return	Net (Unfiltered)
SMA 50/200 Crossover	+89%	-48%	+41%
MACD Crossover	+34%	-67%	-33%
RSI Mean Reversion	+12%	-28%	-16%
Bollinger Band Bounce	+45%	-31%	+14%

Notice the pattern: every strategy is profitable in bull markets and unprofitable in bear markets. The net return depends entirely on whether the bot was running during more bull or bear time.

MACD loses money overall because the bear losses exceed the bull gains. Most developers blame the strategy, but the real culprit is regime blindness.

The Fix: One API Call

import requests

regime = requests.get("https://getregime.com/api/v1/market/regime").json()

if regime["regime"] == "bear" and regime["confidence"] > 0.7:
    position_size = 0  # Don't trade in confirmed bear markets
elif regime["regime"] == "chop":
    position_size *= 0.4  # Reduce in chop
# else: full size in bull

That's it. One API call, one if-statement, and your bot stops bleeding money in bear markets.

The Results

Adding this regime filter to the SMA 50/200 crossover:

Asset	Without Filter	With Filter	Improvement
BTC	+41%	+41% (less DD)	-40% drawdown
ETH	+41%	+166%	+305%
SOL	+312%	+586%	+88%

The filter doesn't make your strategy smarter. It makes your strategy not stupid during the times when being in the market at all is the mistake.

The Deeper Insight

Most losses come from three specific failure modes:

Trading momentum in chop — your trend-following bot gets whipsawed in range-bound markets
Holding longs in bear — your bot bought the "dip" that kept dipping
Using tight stop losses with leverage — 3% SL + 5x leverage gets stopped out by normal volatility

All three are solved by regime awareness.

Get Started

Free API, no auth needed:

curl https://getregime.com/api/v1/market/regime

Python bot example: github.com/Thordersonjg/regime-trading-bot

Running Freqtrade? There's a drop-in regime filter that adds exactly this gate to your existing strategy — open-source at github.com/Thordersonjg/freqtrade-regime-filter. Grab it + a free API key (auto-provisioned) at getregime.com/freqtrade-strategy.

Full tutorial: getregime.com/blog/crypto-regime-detection-python-tutorial

npm SDK: npm install getregime

Try Regime Intelligence

Regime is a real-time crypto market regime detection API. One endpoint tells you if the market is bull, bear, or chop — so your bot only trades when conditions match your strategy.

Free API access → | See pricing → | API docs →

What is Crypto Market Regime Detection? A Complete Guide

Gunnar Thorderson — Fri, 24 Jul 2026 09:00:11 +0000

What is Crypto Market Regime Detection? A Complete Guide

Every profitable crypto trader — whether human or algorithmic — eventually arrives at the same realization: the strategy that works in a bull market will destroy your capital in a bear market.

Market regime detection is the systematic solution to this problem. Instead of guessing whether "we're in a bull market," regime detection uses quantitative signals to classify the current market environment into distinct states — typically bull, bear, or chop (sideways/ranging) — with a measurable confidence score.

In this guide, we'll break down exactly what regime detection is, why it matters, how it works under the hood, and how you can integrate it into your trading stack with a single API call.

Why Market Regime Matters

Consider two simple scenarios:

Scenario A — Bull Market (Q4 2024): BTC is trending up, altcoins are outperforming, funding rates are positive but not extreme, and Fear & Greed is at 72. A momentum strategy buying breakouts returns +40% in 3 months.

Scenario B — Bear Market (Q2 2022): BTC is in a downtrend, altcoins are bleeding, funding rates are negative, and Fear & Greed is at 15. That same breakout strategy returns -60%.

The strategy didn't change. The regime changed.

This is why regime detection is the single most valuable input for any systematic trading system. It answers the question every other signal depends on: "What type of market are we in right now?"

The Cost of Ignoring Regime

Without regime awareness, traders typically:

Run bull-market strategies in bear markets — leading to cascading losses
Size positions uniformly — taking the same risk in high-volatility chop as in clean trends
Miss regime transitions — staying long weeks after the market has shifted bearish
Over-optimize for one regime — building strategies that backtest beautifully in trending markets but blow up in chop

Academic research consistently shows that regime-conditional strategies outperform static strategies by 30-60% on a risk-adjusted basis (Ang & Bekaert, 2002; Guidolin & Timmermann, 2007).

How Regime Detection Works

At its core, regime detection combines multiple market signals into a single classification. There are several approaches, ranging from simple to sophisticated.

Approach 1: Single-Indicator Rules

The simplest form: "If BTC is above the 200-day moving average, we're bullish."

Problems: Whipsaws constantly. A single indicator can't capture the multi-dimensional nature of market regimes. The Fear & Greed Index, for example, has a correlation of only ~0.3 with actual forward returns.

Approach 2: Weighted Ensemble Scoring

A more robust approach combines multiple signals with weights:

Trend signals: Price vs. moving averages (SMA 50/200), momentum (RSI, MACD)
Volatility signals: Realized vol, VIX, Bollinger Band width
Sentiment signals: Fear & Greed Index, social sentiment, funding rates
Macro signals: DXY strength, treasury yields, equity correlation
On-chain signals: Exchange flows, active addresses, stablecoin supply
Futures signals: Open interest changes, liquidation imbalances, funding rate skew

Each signal votes bull, bear, or neutral, and a weighted sum produces a composite score that maps to a regime classification with a confidence level.

Approach 3: Hidden Markov Models (HMM)

The most mathematically rigorous approach uses Hidden Markov Models to infer unobservable "hidden states" (regimes) from observable market data. The HMM learns:

Transition probabilities: How likely is the market to switch from bull to bear?
Emission probabilities: What do observable signals look like in each regime?
State persistence: How "sticky" is each regime?

HMMs are particularly powerful because they capture the empirical observation that regimes are persistent — once a bear market starts, it tends to continue for weeks or months, not days.

How Regime Combines All Three

The Regime API uses an ensemble approach that combines weighted scoring with HMM confirmation:

9 data sources feed into signal extraction (Binance, CoinGecko, CoinGlass, DeFiLlama, FRED, Yahoo Finance, Alternative.me, and more)
13 individual signals are extracted and normalized
Weighted ensemble voting produces a primary classification with confidence
HMM regime detector provides an independent Bayesian confirmation
Category caps prevent any single signal category from dominating (max 45%)
Final output: { regime: "bull" | "bear" | "chop", confidence: 0.0-1.0 }

The Three Regimes Explained

Bull Regime

Characteristics: Rising prices, positive momentum, expanding volume, positive funding rates, improving sentiment
Confidence threshold: Typically >0.6 for high-confidence bull
Trading implications: Favor long positions, increase position sizes, use wider stops, hold trend-following strategies

Bear Regime

Characteristics: Falling prices, negative momentum, capitulation volume spikes, negative funding, extreme fear
Confidence threshold: Typically >0.6 for high-confidence bear
Trading implications: Reduce exposure or go short, tighten position sizes, use mean-reversion strategies on bounces, increase cash allocation

Chop Regime

Characteristics: Range-bound prices, mixed signals, moderate volume, oscillating sentiment
Confidence threshold: Often <0.5 (low confidence in either direction)
Trading implications: Reduce position sizes, use range-bound strategies, avoid trend-following, tighten stops

Integrating Regime Detection Into Your Stack

Quick Start: One API Call

The fastest way to add regime awareness to your trading bot:

curl https://getregime.com/api/v1/market/regime

Response:

{
  "regime": "bear",
  "confidence": 0.73,
  "signals": {
    "trend": -0.6,
    "momentum": -0.4,
    "volatility": 0.2,
    "sentiment": -0.8,
    "macro": -0.3,
    "futures": -0.5
  },
  "timestamp": "2026-03-26T14:00:00Z"
}

Python Integration

import requests

def get_regime():
    r = requests.get("https://getregime.com/api/v1/market/regime")
    data = r.json()
    return data["regime"], data["confidence"]

regime, confidence = get_regime()

if regime == "bear" and confidence > 0.6:
    position_size *= 0.25  # Cut size by 75% in confident bear
elif regime == "chop":
    position_size *= 0.5   # Half size in chop
# Bull with high confidence: full size

JavaScript/TypeScript (SDK)

import { RegimeClient } from 'getregime';

const client = new RegimeClient({ apiKey: 'your-key' });
const { regime, confidence } = await client.getRegime();

// Adjust your strategy based on regime
const sizeMultiplier = {
  bull: 1.0,
  bear: 0.25,
  chop: 0.5
}[regime] ?? 0.5;

Using Regime with Popular Frameworks

Freqtrade — Add regime as a custom indicator in your strategy:

def populate_indicators(self, dataframe, metadata):
    regime = requests.get("https://getregime.com/api/v1/market/regime").json()
    dataframe['regime'] = regime['regime']
    dataframe['regime_confidence'] = regime['confidence']
    return dataframe

CCXT bots — Check regime before every trade decision:

regime, conf = get_regime()
if regime == "bear" and conf > 0.7:
    logger.info("Skipping long entry — high-confidence bear regime")
    return

Beyond Simple Classification

Regime detection is just the starting point. Advanced applications include:

Regime-Based Position Sizing

Scale position sizes dynamically based on regime confidence. A 90% confidence bull signal warrants larger positions than a 55% confidence bull.

Regime Transition Alerts

The most profitable moments often occur at regime transitions — when the market shifts from bear to bull, or bull to chop. Regime's intelligence endpoints provide historical transition data so you can detect shifts early.

Multi-Signal Divergence Detection

When individual signals disagree with the overall regime (e.g., Fear & Greed is euphoric but macro signals are deteriorating), it often signals an upcoming regime change. The Regime API exposes individual signal components for exactly this analysis.

Risk Management Overlay

Use regime as a portfolio-level risk overlay:

Bull: Normal leverage, full allocation
Chop: Reduce leverage 50%, increase stablecoin allocation
Bear: Minimal leverage, defensive allocation, consider hedges

Why Not Just Use Fear & Greed?

The Crypto Fear & Greed Index is the most popular single-number market summary. But it has critical limitations:

Lagging: It's heavily weighted toward recent price action, so it tells you what already happened
One-dimensional: A single number can't capture trend + volatility + sentiment + macro simultaneously
No confidence score: Fear & Greed of 45 vs. 55 looks similar, but the underlying signals might be completely different
Poor predictive power: Extreme fear/greed readings have only ~55% accuracy for predicting 7-day returns

Regime detection solves these problems by combining Fear & Greed with 12 other signals and outputting both a classification and a confidence score.

Getting Started

Free tier: 30 requests/minute, BTC/ETH/SOL, 15-minute delay — sign up here
Pro tier ($49/mo): 100 RPM, all assets, real-time, full intelligence suite
SDK: npm install getregime — TypeScript client with full type safety
API docs: getregime.com/quickstart

Regime detection is the foundation that every other trading decision should build on. Whether you're running a Freqtrade bot, a custom Python strategy, or managing a crypto portfolio manually — knowing what regime you're in changes everything.

Regime is a real-time crypto market intelligence API. Get your free API key and classify markets in one call.

Try Regime Intelligence

Regime is a real-time crypto market regime detection API. One endpoint tells you if the market is bull, bear, or chop — so your bot only trades when conditions match your strategy.

Free API access → | See pricing → | API docs →

Weekly Regime Recap: BEAR (Capitulation) at 74% — April 1, 2026

Gunnar Thorderson — Thu, 23 Jul 2026 09:00:15 +0000

Weekly Regime Recap — April 1, 2026

Current Classification: BEAR — Capitulation (74% confidence)

The Regime classifier reads BEAR with a capitulation subtype at 74% confidence. This is a shift from last week's 93% standard bear — confidence has dropped while the subtype has worsened.

Capitulation subtypes historically mark the late stages of a drawdown, where panic selling accelerates but exhaustion is approaching. Not a reversal signal — but the setup that precedes one.

Market Snapshot

Metric	Value	Change
BTC Price	$68,124	—
ETH Price	$2,142	—
Fear & Greed	8/100	Extreme Fear
BTC Dominance	56.1%	Elevated
Total Market Cap	$2.43T	—
DeFi TVL	$94B	—

Signal Breakdown

Signal Direction	Count
Bearish	4
Neutral	3
Bullish	1

Four bearish signals still dominate, but three neutral signals suggest the bear pressure is losing conviction. One bullish signal (likely the volume or stablecoin metric) is starting to diverge from the crowd.

What Changed This Week

Fear & Greed collapsed to 8 — the lowest reading since the regime classification started. This is deep fear territory. Historically, single-digit F&G readings precede 2-4 week reversals, but timing is unreliable.
Capitulation subtype — the classifier now labels this as capitulation rather than standard bear. This means we're seeing accelerated selling with volume spikes, which typically indicates late-cycle panic.
Confidence dropped from 93% to 74% — counterintuitively, this is interesting. Falling confidence in a bear regime means the signals are starting to disagree. Some metrics are turning neutral or bullish while others remain bearish. Regime transitions usually start with confidence erosion.

What To Do

If you're running a trading bot:

Regime-based position sizing suggests 40-60% of normal size
Short-only strategies are still favored, but tighten stops — capitulation phases can reverse violently
The /api/v1/intelligence/crowd-positioning endpoint shows funding rate bias — check if shorts are getting crowded

If you're a long-term allocator:

Single-digit Fear & Greed + capitulation subtype is historically a strong accumulation zone on a 3-6 month horizon
DCA timing models favor small entries when F&G < 15
Wait for regime confidence to drop below 50% before increasing size

If you're sitting in cash:

This is what you were waiting for. Capitulation + Extreme Fear is the setup, not the entry signal.
The entry signal is regime transition: BEAR → CHOP at declining confidence. Set up a webhook to get notified when it happens.

Track Record Update

Our track record page shows +9.48% alpha over buy-and-hold across 4,941 snapshots (29 days). Regime-following returned +7.59% while BTC buy-and-hold returned -1.89%.

New This Week

Webhook filters — filter by asset, regime state, or signal strength
CSV signal exports — download full signal history for backtesting
New blog post: How to Backtest by Market Regime — split your backtest performance by bull/bear/chop to find where your edge actually lives

Get the live regime classification:

curl https://getregime.com/api/v1/market/regime

Full intelligence (Pro): GET /api/v1/intelligence/brief — Quickstart

Try Regime Intelligence

Regime is a real-time crypto market regime detection API. One endpoint tells you if the market is bull, bear, or chop — so your bot only trades when conditions match your strategy.

Free API access → | See pricing → | API docs →

Weekly Regime Recap: BEAR at 93% — March 31, 2026

Gunnar Thorderson — Thu, 23 Jul 2026 09:00:11 +0000

Weekly Regime Recap — March 31, 2026

Current Classification: BEAR (93% confidence)

The Regime classifier continues to read BEAR with 93% confidence. Here's the weekly breakdown.

Market Snapshot

Metric	Value
BTC	$66,626
ETH	$2,043
Fear & Greed	11 (Extreme Fear)
BTC Dominance	56.1%
Regime	BEAR at 93%

Signal Breakdown

Bullish signals: 0
Bearish signals: 4
Neutral signals: 4

Data Moat Update

8,232 market snapshots collected
70 regime transitions tracked
30 days of continuous monitoring

What This Means for Traders

Bear regime = capital preservation mode. Reduce long exposure to 10-15% of normal. Don't try to catch the bottom. The regime flip from bear to chop is the first signal to watch for.

At 11 Fear & Greed (Extreme Fear), sentiment is extremely negative. Historically, extreme fear persists during bear markets — it's a necessary condition for a bottom but not sufficient on its own.

Track This Live

curl https://getregime.com/api/v1/market/regime

Free API, no auth needed. Full docs | Pricing

Try Regime Intelligence

Regime is a real-time crypto market regime detection API. One endpoint tells you if the market is bull, bear, or chop — so your bot only trades when conditions match your strategy.

Free API access → | See pricing → | API docs →

The Stop Loss Myth: Why Fixed Stop Losses Destroy Crypto Trading Returns

Gunnar Thorderson — Wed, 22 Jul 2026 09:00:14 +0000

The Stop Loss Myth: Why Fixed Stop Losses Destroy Crypto Trading Returns

"Always use a stop loss" is the most commonly repeated advice in crypto trading. It's in every tutorial, every course, every YouTube video. And for most systematic trend-following strategies, it's wrong.

This isn't theoretical. We backtested SMA 50/200 crossover strategies across 302,000+ candles on BTC, ETH, and SOL from March 2023 to March 2026, with and without stop losses at various levels. The results were unambiguous: fixed stop losses reduced returns in every single configuration we tested.

The Backtest Setup

We tested the SMA 50/200 crossover on three assets across two timeframes, with 5x leverage:

BTC — 1-day candles
ETH — 1-day candles
SOL — 4-hour candles

For each configuration, we ran the strategy with:

No stop loss (signal flip is the exit)
3% stop loss
5% stop loss
10% stop loss
15% stop loss

Every other parameter was identical: same entry logic, same position sizing, same leverage.

The Results

SOL 4h, SMA 50/200, 5x Leverage

Stop Loss	Total Return	Max Drawdown	Trades	Win Rate
None	+586%	-34%	47	44%
15%	+312%	-31%	89	38%
10%	+141%	-29%	134	33%
5%	-28%	-45%	267	27%
3%	-89%	-92%	412	22%

ETH 1d, SMA 50/200, 5x Leverage

Stop Loss	Total Return	Max Drawdown	Trades	Win Rate
None	+166%	-28%	31	48%
15%	+98%	-26%	52	40%
10%	+34%	-24%	78	35%
5%	-41%	-53%	143	28%
3%	-82%	-87%	231	23%

BTC 1d, SMA 50/200, 5x Leverage

Stop Loss	Total Return	Max Drawdown	Trades	Win Rate
None	+41%	-18%	28	46%
15%	+22%	-16%	41	41%
10%	+3%	-15%	59	37%
5%	-35%	-41%	97	30%
3%	-71%	-78%	168	24%

The pattern is consistent across all three assets: tighter stop losses produce worse results.

Why Fixed Stop Losses Fail in Crypto

1. Crypto Volatility Exceeds Typical Stop Levels

Bitcoin's average daily range is 3-5%. With 5x leverage, a 3% stop loss gets triggered by a 0.6% adverse move — which happens multiple times per day, even during healthy trends.

This means your stop loss isn't protecting you from trend reversals. It's getting triggered by normal intraday noise, kicking you out of winning positions that would have recovered within hours.

2. The Re-Entry Problem

When a stop loss triggers, the SMA crossover signal hasn't changed. The 50-period SMA is still above the 200. So what does the bot do? It re-enters the position on the next evaluation cycle. But now it's buying at a worse price (because the dip that triggered the stop has already bounced), and it's paying fees on both the exit and re-entry.

Over hundreds of trades, this "stop-trigger-reenter" cycle creates a massive fee drag:

412 trades (3% SL on SOL) vs 47 trades (no SL) = 8.7x more fees
At 0.1% per round trip, that's an additional 36.5% in fees alone
Plus slippage on each entry/exit, compounding the damage

3. Stop Losses Solve the Wrong Problem

The purpose of a stop loss is to limit losses on a single trade. But for a trend-following strategy, the SMA crossover itself is the stop loss. When the 50 SMA crosses below the 200 SMA, the strategy exits. This is a regime-aware exit: it tells you the trend has changed, not just that price dipped temporarily.

A fixed stop loss says: "Exit if price drops X%." A signal-based exit says: "Exit when the trend actually reverses." The second approach endures temporary drawdowns in exchange for capturing the full trend.

The Math: Why 3% SL + 5x Leverage = Account Destruction

Let's trace through a specific example.

Setup: BTC at $60,000, long position, 5x leverage, 3% stop loss.

BTC drops 0.6% to $59,640 (perfectly normal hourly candle).
With 5x leverage, your position is down 3%. Stop triggers. You exit.
BTC bounces to $60,200 over the next 4 hours.
Your SMA signal still says LONG. You re-enter at $60,200.
You've lost 0.6% on the stop + 0.33% on the worse re-entry + 0.2% in fees.
Net cost of this single whipsaw: ~1.1% of position size.

Now multiply this by the 168 stop-triggered exits we saw in the BTC 3% SL backtest. That's roughly 185% in cumulative whipsaw damage — enough to destroy any edge the strategy has.

What to Use Instead

Signal-Based Exits (Strategy Flip)

The simplest and most effective exit for trend-following strategies: exit when the strategy signal flips. For SMA 50/200, you exit your long when the 50 crosses below the 200. No fixed percentage. No arbitrary threshold.

This means you'll sometimes sit through 15-20% drawdowns on a leveraged position. That's uncomfortable. But the data shows it's profitable.

Regime-Based Sizing (The Better Risk Management)

Instead of using stop losses to manage risk, use regime-aware position sizing to control your exposure dynamically.

import requests

def get_position_size(base_size: float) -> float:
    """Use regime detection to size positions instead of stop losses."""
    resp = requests.get('https://getregime.com/api/v1/market/regime')
    regime = resp.json()

    confidence = regime['confidence']
    state = regime['regime']

    if state == 'chop':
        # Choppy market = small positions (where whipsaws live)
        return base_size * 0.3

    if state == 'bear':
        # Bear regime = reduce longs, full shorts
        return base_size * confidence

    if state == 'bull':
        # Bull regime = scale with confidence
        return base_size * (0.5 + 0.5 * confidence)

    return base_size

# Instead of: $10K position + 3% stop loss
# Use: Dynamic sizing based on regime
size = get_position_size(10000)
print(f"Regime-adjusted size: ${size:,.0f}")

This approach achieves what stop losses try to do — limit risk — without the whipsaw problem. In a choppy, uncertain market (where stops get triggered constantly), your position is already small. In a high-confidence trend (where you want full exposure), you're fully sized.

Drawdown-Based Scaling

Another alternative: scale position size inversely with portfolio drawdown. As your account draws down, positions automatically shrink.

import { RegimeClient } from 'getregime';

const regime = new RegimeClient();

function drawdownScaling(currentEquity: number, peakEquity: number): number {
  const drawdown = (peakEquity - currentEquity) / peakEquity;

  // Quadratic scaling: gentle at first, aggressive as DD deepens
  // 5% DD = 90% size, 10% DD = 64% size, 20% DD = 25% size
  const scale = Math.max(0.1, (1 - drawdown) ** 2);
  return scale;
}

async function smartPositionSize(baseSize: number, equity: number, peak: number) {
  // Layer 1: Regime sizing
  const market = await regime.getRegime();
  let size = baseSize;

  if (market.regime === 'chop') size *= 0.3;
  else size *= (0.5 + 0.5 * market.confidence);

  // Layer 2: Drawdown scaling
  size *= drawdownScaling(equity, peak);

  return Math.round(size);
}

// Example: $10K base, currently at $8.5K (15% drawdown from $10K peak)
const size = await smartPositionSize(10000, 8500, 10000);
console.log(`Position size: $${size}`);
// With bear regime (0.6 confidence) + 15% DD: ~$2,890
// vs fixed $10K + 3% SL: guaranteed whipsaw death

When Fixed Stop Losses DO Make Sense

To be fair, there are scenarios where fixed stop losses work:

Mean reversion strategies. If you're buying oversold bounces with a 1-2 hour holding period, a tight stop loss prevents a bounce trade from becoming a bag-hold. The key difference: mean reversion expects quick resolution, so a stop loss catches genuine failures.

Event-driven trades. Trading a specific catalyst (token unlock, ETF decision) with a defined invalidation point. If the thesis breaks, you want out immediately.

Unleveraged spot positions. Without leverage, a 3% stop loss requires a genuine 3% move to trigger. This is far less prone to noise-triggered exits.

High-frequency strategies. Sub-minute holding periods where stop losses protect against flash crashes during execution.

The common thread: stop losses work when your expected holding period is short and your thesis has a clear invalidation point. For trend following — where you're riding multi-week moves — the trend signal itself is the only valid exit.

The Core Insight

Risk management is critical. But risk management and stop losses are not the same thing.

Effective risk management for trend following means:

Position sizing — Smaller positions in uncertain markets (regime detection handles this)
Drawdown scaling — Automatic de-risking as the account draws down
Signal-based exits — Exit when the trend reverses, not when price dips
Portfolio correlation — Don't run the same strategy on correlated assets at full size

Fixed stop losses are a blunt instrument that solves the wrong problem. They limit single-trade losses at the cost of systematically destroying the positive-expectancy trades that make trend following profitable.

Summary

Approach	Return (ETH 1d, 5x)	Max DD	Trade Count
No SL (signal flip exit)	+166%	-28%	31
15% SL	+98%	-26%	52
5% SL	-41%	-53%	143
3% SL	-82%	-87%	231
Regime sizing + no SL	+166%	-22%	31

The regime-sizing approach matches the no-SL return while reducing maximum drawdown by 6 percentage points — because smaller positions in choppy/uncertain markets mean the inevitable drawdowns are shallower.

Want to replace stop losses with regime-aware sizing? The Regime API gives you real-time market regime classification for free at getregime.com/quickstart. One API call tells your bot whether to go full size, reduce exposure, or sit on its hands — no arbitrary stop loss required.

Try Regime Intelligence

Regime is a real-time crypto market regime detection API. One endpoint tells you if the market is bull, bear, or chop — so your bot only trades when conditions match your strategy.

Free API access → | See pricing → | API docs →

New: Regime Subtypes and Historical Point-in-Time Queries

Gunnar Thorderson — Wed, 22 Jul 2026 09:00:10 +0000

New: Regime Subtypes and Historical Point-in-Time Queries

Two features that systematic traders have been asking for are now live.

Regime Subtypes

Not all bear markets are the same. A deleveraging crash behaves completely differently from a slow grind. The regime endpoint now returns a regimeSubtype field:

Bear subtypes:

deleveraging — high volatility + negative funding + liquidation cascades
grinding — low volatility + low volume + slow bleed
capitulation — extreme fear + low volatility (potential bottom formation)
standard — doesn't fit a specific pattern

Bull subtypes:

euphoric — high volume + positive funding (potential top)
accumulation — low volatility + quiet buying
trending — standard uptrend

Chop subtypes:

compression — tightening range (breakout incoming)
choppy — wide range, no direction

curl https://getregime.com/api/v1/market/regime

{
  "regime": "chop",
  "regimeSubtype": "compression",
  "confidence": 0.17,
  "regimeDurationHours": 0.5,
  "regimeStartedAt": 1774580000000
}

The subtype is derived from the same 10 weighted signals — it's an interpretation layer, not a separate model. Available on all tiers.

Historical Point-in-Time Queries

"What was the regime on November 15, 2024 at 2pm UTC?" Now you can answer that:

curl -H "Authorization: Bearer YOUR_KEY" \
  "https://getregime.com/api/v1/intelligence/regime-at?ts=1731686400000"

Accepts epoch milliseconds or ISO 8601 strings. Returns the regime, confidence, all signal values, when that regime started, and how long it had been running at that point.

This is the feature that makes Regime irreplaceable for backtesting — you can now condition your strategy performance analysis on the market regime at every point in history.

Pro tier required. We have 7,000+ snapshots since March 2, 2026.

Regime Duration

Every regime response now includes duration:

{
  "regimeStartedAt": 1741669198786,
  "regimeDurationMs": 1374523214,
  "regimeDurationHours": 381.8
}

Duration alone is a useful signal — a bear regime that's been running for 400 hours behaves differently from one that just started.

Try It

curl https://getregime.com/api/v1/market/regime

Full docs: getregime.com/quickstart

Try Regime Intelligence

Regime is a real-time crypto market regime detection API. One endpoint tells you if the market is bull, bear, or chop — so your bot only trades when conditions match your strategy.

Free API access → | See pricing → | API docs →

Crypto Regime Detection API vs Building Your Own: The Real Cost

Gunnar Thorderson — Tue, 21 Jul 2026 09:00:14 +0000

Crypto Regime Detection API vs Building Your Own: The Real Cost

Every systematic crypto trader eventually asks: "Should I build my own regime detector or use someone else's?"

I built one. It took 4 months, $35/mo in data feeds, and roughly 400 hours of engineering. Here's the honest breakdown so you can decide.

What a Regime Detector Actually Needs

A useful regime classifier (not a toy) needs:

Multiple uncorrelated signals — single indicators (just RSI, just SMA) overfit. You need 4-10 signals from different categories.
Multiple data sources — no single API gives you everything. You need price data, derivatives data, on-chain data, macro data, and sentiment data.
A classification engine — weighted voting, HMM, or ensemble that turns signal values into bull/bear/chop.
24/7 reliability — markets don't sleep. Your detector can't either.
Historical data — you need to validate that your classifications match historical price action.

The Data Feed Cost

Here's what Regime uses:

Source	Data	Cost
Binance	Spot price, volume, order book, candles	Free
CoinGecko	Market cap, dominance, stablecoin supply	Free (30 req/min)
CoinGlass	Funding rates, OI, liquidations	$35/mo
Alternative.me	Fear & Greed Index	Free
DeFiLlama	DeFi TVL	Free
FRED	DXY, Fed funds rate, 10Y treasury	Free
Yahoo Finance	SPX, Gold, VIX	Free
Hyperliquid	Live funding rates (backup)	Free

Total: $35/mo for 9 data sources.

That's cheap — but it's also 9 different APIs with 9 different authentication methods, rate limits, response formats, and failure modes. That's where the engineering cost lives.

The Engineering Cost

Assuming you're a competent developer (you know Node or Python, you've built APIs before):

Component	Time	Notes
Data fetchers (9 sources)	40h	Each source has quirks, rate limits, pagination
Signal calculations (10 signals)	30h	SMA crossover, funding analysis, vol regime, etc.
Classification engine	20h	Weighted voting + confidence scoring
Storage (SQLite/Postgres)	15h	Schema, migrations, data retention
API server	20h	Express/Fastify routes, auth, rate limiting
Monitoring/alerts	15h	What happens when CoinGlass goes down at 3am?
Testing	20h	Backtest validation, integration tests
Deployment (PM2, tunnels, SSL)	15h	Production ops
Maintenance (ongoing)	5h/mo	API changes, data source outages, schema updates

Initial build: ~175 hours. At $100/hr consulting rate, that's $17,500 of your time.

Then add $35/mo for CoinGlass and ~5 hours/month of maintenance.

The API Option

Regime does all of the above for $49/mo (Pro) or $149/mo (Institutional):

# One call returns bull/bear/chop + confidence + all 10 signals
curl https://getregime.com/api/v1/market/regime

# Or get everything synthesized into an intelligence brief
curl -H "Authorization: Bearer YOUR_KEY" \
  https://getregime.com/api/v1/intelligence/brief

Year 1 cost comparison:

Approach	Year 1 Cost	Ongoing
Build your own	$17,500 + $420 (data)	$6,420/yr (data + 60h maintenance)
Regime Pro	$1,188/yr	$1,188/yr
Regime Institutional	$5,988/yr ($149/mo)	$5,988/yr

The Institutional tier includes full historical data for backtesting (8,400+ snapshots), batch regime-at queries, and signal archive exports.

When to Build Your Own

Build your own if:

You need custom signals not covered by the 10 in Regime's classifier
You're running a fund with compliance requirements that prevent using third-party classification
You want to train ML models on raw signal data (though Regime exports the raw values too)
You have a team and the 175 hours isn't a bottleneck

When to Use the API

Use the API if:

You're a solo trader or small team
You want to focus on strategy development, not data infrastructure
You need a quick answer ("is this a bear market?") without building the plumbing
You want to validate your own regime model against an independent classifier
You need historical regime data for backtesting

The Middle Ground

Some traders use both: they build a simple 3-4 signal classifier for their primary system, then use Regime as an independent confirming signal. If both agree, high confidence. If they disagree, reduce size. This is actually the approach our most technical user is taking.

Try It

# Free tier — no auth needed
curl https://getregime.com/api/v1/market/regime

# Pro tier — 14-day free trial, no credit card
# Register: POST https://getregime.com/api/v1/auth/register

Full docs at getregime.com/quickstart.

Try Regime Intelligence

Regime is a real-time crypto market regime detection API. One endpoint tells you if the market is bull, bear, or chop — so your bot only trades when conditions match your strategy.

Free API access → | See pricing → | API docs →

How to Build a Regime-Aware Trading Bot with Freqtrade

Gunnar Thorderson — Tue, 21 Jul 2026 09:00:10 +0000

How to Build a Regime-Aware Trading Bot with Freqtrade

Most Freqtrade strategies treat every market condition the same. An EMA crossover fires in a bull market? Buy. Same crossover in a grinding bear? Also buy. Then you wonder why your backtest looked great but live trading bled out over three months.

The fix isn't a better indicator. It's knowing when to trade and when to sit out.

This tutorial shows you how to plug market regime detection into a Freqtrade strategy so your bot automatically adapts — aggressive in bull markets, defensive in chop, and sidelined in bear conditions.

What You'll Build

A Freqtrade strategy that:

Calls the Regime API every 5 minutes for regime classification (bull/bear/chop)
Adjusts position sizing based on regime confidence
Uses different entry signals per regime (trend-following in bull, mean-reversion in chop)
Refuses new longs in bear markets
Caches API responses to stay within rate limits

Prerequisites

A running Freqtrade installation (docs)
A Regime API key (free tier works for testing — register here)
Python 3.11+ with requests installed

Step 1: Get Your API Key

curl -X POST https://getregime.com/api/v1/auth/register \
  -H 'Content-Type: application/json' \
  -d '{"email":"you@email.com","name":"freqtrade-bot"}'

Save the apiKey from the response. Add it to your Freqtrade config:

{
  "regime_api_key": "cse_free_abc123...",
  "regime_api_url": "https://getregime.com"
}

Step 2: The Regime Client

Add this to your strategy file — it handles API calls, caching, and fallback:

import requests
from datetime import datetime, timedelta, timezone

class RegimeClient:
    def __init__(self, api_key: str, base_url: str = "https://getregime.com"):
        self.api_key = api_key
        self.base_url = base_url
        self._cache = None
        self._cache_time = None
        self._cache_ttl = timedelta(minutes=5)

    def get_regime(self) -> dict:
        now = datetime.now(timezone.utc)
        if self._cache and self._cache_time and (now - self._cache_time) < self._cache_ttl:
            return self._cache

        try:
            resp = requests.get(
                f"{self.base_url}/api/v1/market/regime",
                headers={"X-API-Key": self.api_key},
                timeout=10
            )
            resp.raise_for_status()
            self._cache = resp.json()
            self._cache_time = now
            return self._cache
        except Exception:
            return self._cache or {"regime": "unknown", "confidence": 0}

The 5-minute cache matches the API's data refresh rate. If the API is unreachable, the last known regime is used — your bot doesn't crash because of a network blip.

Step 3: Regime-Aware Entry Logic

Here's the core idea: different market conditions call for different entry strategies.

from freqtrade.strategy import IStrategy
import talib.abstract as ta

class RegimeAwareStrategy(IStrategy):
    INTERFACE_VERSION = 3
    timeframe = '5m'
    stoploss = -0.05
    can_short = False

    def __init__(self, config: dict) -> None:
        super().__init__(config)
        self.regime_client = RegimeClient(
            api_key=config.get('regime_api_key', ''),
            base_url=config.get('regime_api_url', 'https://getregime.com')
        )

    def populate_indicators(self, dataframe, metadata):
        dataframe['ema_8'] = ta.EMA(dataframe, timeperiod=8)
        dataframe['ema_21'] = ta.EMA(dataframe, timeperiod=21)
        dataframe['bb_upper'] = ta.BBANDS(dataframe, timeperiod=20)[0]
        dataframe['bb_lower'] = ta.BBANDS(dataframe, timeperiod=20)[2]
        dataframe['rsi'] = ta.RSI(dataframe, timeperiod=14)
        return dataframe

    def populate_entry_trend(self, dataframe, metadata):
        regime_data = self.regime_client.get_regime()
        regime = regime_data.get('regime', 'unknown')
        confidence = regime_data.get('confidence', 0)

        if regime == 'bull' and confidence > 0.6:
            # Trend-following: EMA crossover
            dataframe.loc[
                (dataframe['ema_8'] > dataframe['ema_21']) &
                (dataframe['rsi'] < 70),
                'enter_long'
            ] = 1

        elif regime == 'chop':
            # Mean-reversion: Bollinger bounce
            dataframe.loc[
                (dataframe['close'] < dataframe['bb_lower']) &
                (dataframe['rsi'] < 35),
                'enter_long'
            ] = 1

        # Bear regime: no entries. Bot sits out.
        return dataframe

Step 4: Regime-Based Position Sizing

Don't just change your signals — change your conviction:

    def custom_stake_amount(self, current_time, current_rate, proposed_stake,
                           min_stake, max_stake, leverage, entry_tag, side, **kwargs):
        regime_data = self.regime_client.get_regime()
        regime = regime_data.get('regime', 'unknown')
        confidence = regime_data.get('confidence', 0)

        multiplier = {
            'bull': 1.0,      # Full size
            'chop': 0.5,      # Half size
            'bear': 0.0,      # No new positions
        }.get(regime, 0.25)

        # Scale by confidence: 74% confidence = 74% of multiplier
        adjusted = proposed_stake * multiplier * min(confidence, 1.0)
        return max(min_stake, min(adjusted, max_stake))

Step 5: Dynamic Stop-Loss

Tighten stops in choppy markets, let winners run in trends:

    def custom_stoploss(self, current_time, current_rate, current_profit,
                       after_fill, **kwargs):
        regime_data = self.regime_client.get_regime()
        regime = regime_data.get('regime', 'unknown')

        if regime == 'bull':
            return -0.08  # Wide stop for trending markets
        elif regime == 'chop':
            return -0.03  # Tight stop for ranging markets
        else:
            return -0.02  # Very tight in bear — protect capital

Running It

freqtrade trade --strategy RegimeAwareStrategy \
  --config user_data/config.json

Check your logs for regime state:

2026-04-12 08:00:05 - RegimeAwareStrategy - Regime: bear (74% confidence, grinding)
2026-04-12 08:00:05 - RegimeAwareStrategy - Position multiplier: 0.0 — sitting out

Free vs Pro Tier

The free tier gives you regime classification with a 15-minute delay — fine for backtesting and development. For live trading where you need real-time regime shifts and signal breakdowns, Pro at $49/mo removes the delay and adds the /signals/all endpoint for individual signal weights.

The dedicated Freqtrade endpoint (/api/v1/freqtrade/regime) returns a simplified response optimized for bot consumption.

What the Data Actually Looks Like

As of today, Regime has classified 9,285 market snapshots across 266 regime transitions. The current bear phase has been grinding for 59 hours at 74% confidence. That's the kind of sustained directional read that keeps your bot from buying dips in a downtrend.

The regime detector uses 10 signals: funding rates, open interest changes, Fear & Greed, DeFi TVL flows, stablecoin supply, macro divergences (DXY, VIX), and volume-weighted price action. It's not a single indicator — it's a composite classifier.

Full Strategy Template

A complete, production-ready strategy file is open-source at github.com/Thordersonjg/freqtrade-regime-filter — drop-in, with logging, fail-open/fail-closed handling, and a config guide. Grab it plus a free API key (auto-provisioned, no card) at getregime.com/freqtrade-strategy.

Building something with Regime data? Reply on Twitter/X or drop a comment in the Freqtrade Discord. We're actively helping builders integrate.

Try Regime Intelligence

Regime is a real-time crypto market regime detection API. One endpoint tells you if the market is bull, bear, or chop — so your bot only trades when conditions match your strategy.

Free API access → | See pricing → | API docs →

Set Up Crypto Regime Shift Webhooks in 5 Minutes

Gunnar Thorderson — Mon, 20 Jul 2026 09:00:12 +0000

Set Up Crypto Regime Shift Webhooks in 5 Minutes

The most valuable moment in crypto is when the market regime changes — bull to bear, bear to chop, chop to bull. If you find out 30 minutes late, you've already lost money.

Regime webhooks notify you the instant a regime transition is detected. Here's how to set them up.

Prerequisites

A Regime Pro account (start free trial)
A webhook URL (Slack, Discord, or your own server)

Step 1: Register a Webhook

curl -X POST https://getregime.com/api/v1/webhooks \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://your-server.com/regime-webhook",
    "events": ["regime.change"]
  }'

Step 2: Receive Events

When the regime changes, you'll receive a POST request:

{
  "event": "regime.change",
  "data": {
    "regime": "bear",
    "previousRegime": "chop",
    "confidence": 0.87,
    "timestamp": "2026-03-26T14:30:00Z",
    "signals": {
      "bullish": 1,
      "bearish": 4,
      "neutral": 1
    }
  },
  "signature": "sha256=abc123..."
}

Slack Integration

Use a Slack incoming webhook URL directly:

curl -X POST https://getregime.com/api/v1/webhooks \
  -H "Authorization: Bearer YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://hooks.slack.com/services/YOUR/WEBHOOK/URL",
    "events": ["regime.change"]
  }'

Discord Integration

Same approach with a Discord webhook:

curl -X POST https://getregime.com/api/v1/webhooks \
  -H "Authorization: Bearer YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://discord.com/api/webhooks/YOUR/WEBHOOK",
    "events": ["regime.change"]
  }'

Verify Signatures

All webhooks are signed with HMAC-SHA256. Verify them to prevent spoofing:

import hmac
import hashlib

def verify_webhook(payload, signature, secret):
    expected = hmac.new(secret.encode(), payload.encode(), hashlib.sha256).hexdigest()
    return hmac.compare_digest(f"sha256={expected}", signature)

Use Case: Auto-Adjust Trading Bot

from flask import Flask, request

app = Flask(__name__)

@app.route("/regime-webhook", methods=["POST"])
def handle_regime_change():
    data = request.json["data"]

    if data["regime"] == "bear" and data["confidence"] > 0.8:
        # Close all longs, reduce exposure
        close_all_positions()
        send_alert(f"BEAR REGIME at {data['confidence']:.0%} — positions closed")
    elif data["regime"] == "bull":
        # Resume normal trading
        enable_trading()

    return "", 200

Full webhook docs: getregime.com/quickstart

Example receiver: github.com/Thordersonjg/regime-webhook-alerts

Try Regime Intelligence

Regime is a real-time crypto market regime detection API. One endpoint tells you if the market is bull, bear, or chop — so your bot only trades when conditions match your strategy.

Free API access → | See pricing → | API docs →

Real-Time Crypto Signals API for Algorithmic Trading

Gunnar Thorderson — Mon, 20 Jul 2026 09:00:08 +0000

Real-Time Crypto Signals API for Algorithmic Trading

If you run a trading bot, you already know the pain. Your signal pipeline is a patchwork of 3-5 different APIs, each with its own rate limits, auth scheme, and failure modes. Binance for price and candles. CoinGecko for market cap data. CoinGlass for funding rates and open interest. Yahoo Finance or FRED for macro indicators. Maybe a manual spreadsheet somewhere to track correlations you noticed once and never automated.

This setup is fragile. When CoinGlass changes their response format at 2am, your bot goes blind. When you hit CoinGecko's free tier rate limit during a volatile move, you miss the signal that mattered. And you are paying $200+/mo in data feeds before you write a single line of strategy logic.

Regime consolidates all of this into one API. One authentication token, one rate limit pool, one response format. Six candle analysis lanes, ten regime indicators, crowd positioning, macro divergences, and order book depth — all queryable from a single base URL.

What the Signals Include

Regime Classification (Free)

This is the primary signal. Regime runs a 10-signal weighted classifier that outputs one of three states: bull, bear, or chop, along with a confidence score between 0 and 1.

The ten signals span on-chain metrics, derivatives data, macro indicators, and price structure. Each signal is weighted based on historical predictive accuracy, and the composite output updates in real time as new data flows in. The regime state is the single most useful pre-trade filter available — it tells you whether the current environment favors trend-following, mean-reversion, or sitting on your hands.

Strategy Signals (Pro)

Six independent candle analysis lanes run continuously, each processing live Binance candle data through SMA crossover and Donchian breakout strategies. A signal is only emitted when the composite score crosses a threshold of 30 or higher, which filters out the noise that plagues most signal services.

Each lane covers a different asset or timeframe combination, giving you cross-asset confirmation without building separate pipelines for each market. The response includes the signal direction, strength score, strategy source, and timestamp — everything your bot needs to decide whether to act.

Crowd Positioning (Pro)

Funding rate bias, liquidation imbalance, and open interest trends — aggregated from Binance and Hyperliquid. This data answers the question every trader should ask before entering: where is the crowd positioned, and how vulnerable are they?

When funding rates are deeply negative and open interest is rising, the crowd is aggressively short. That is useful information for a bot deciding whether to take a long signal. Regime computes the bias and imbalance metrics for you, so your strategy code stays clean.

Macro Divergences (Pro)

DXY-BTC correlation, VIX-crypto relationship, and SPX-BTC divergence. These are the cross-market signals that most crypto-native traders ignore because the data is annoying to source and align.

When BTC is rallying but DXY is strengthening — that is a divergence worth knowing about. When VIX spikes and crypto has not reacted yet, the clock is ticking. Regime pulls DXY and Fed funds rate from FRED, SPX and VIX from Yahoo Finance, and computes the divergence metrics against crypto price action automatically.

Order Book Depth

Bid/ask imbalance from Binance order book data. This is a short-term signal — it tells you whether buyers or sellers are stacking orders at the current price level. Useful for execution timing and for confirming whether a breakout has real depth behind it or is likely to fade.

API Endpoints

All endpoints are served from https://getregime.com. Authentication uses a Bearer token in the Authorization header.

Regime classification (free, no auth required):

curl https://getregime.com/api/v1/market/regime

Returns the current regime state (bull/bear/chop), confidence score, and the individual signal components that drove the classification.

All strategy signals (Pro):

curl -H "Authorization: Bearer YOUR_API_KEY" \
  https://getregime.com/api/v1/signals/all

Returns active signals from all six candle analysis lanes, including direction, strength, strategy type, and asset.

Crowd positioning (Pro):

curl -H "Authorization: Bearer YOUR_API_KEY" \
  https://getregime.com/api/v1/intelligence/crowd-positioning

Returns funding rate bias, liquidation imbalance, and open interest trend data.

Macro divergences (Pro):

curl -H "Authorization: Bearer YOUR_API_KEY" \
  https://getregime.com/api/v1/intelligence/divergences

Returns DXY-BTC, VIX-crypto, and SPX-BTC divergence scores with directional context.

Full intelligence brief (Pro):

curl -H "Authorization: Bearer YOUR_API_KEY" \
  https://getregime.com/api/v1/intelligence/brief

Returns a synthesized view combining regime state, crowd positioning, macro context, and risk assessment in a single response. This is the endpoint to call if you want everything in one request.

How Algo Traders Use This

Pre-Trade Filter

The simplest and highest-impact integration: check the regime before every entry. If your bot runs a momentum strategy, skip entries during chop regimes. If you run mean-reversion, skip entries during strong bull trends. One API call, one conditional, measurably fewer losing trades.

regime = requests.get("https://getregime.com/api/v1/market/regime").json()
if regime["state"] == "chop" and strategy_type == "momentum":
    skip_trade()

Signal Confirmation

Use the strategy signals endpoint as a second opinion for your existing technical setups. Your bot identifies a breakout on the 4h chart — before executing, check whether any of the six candle lanes agree. Confirmation from an independent signal source reduces false positive entries.

Risk Management

Crowd positioning data directly informs position sizing. When the crowd is heavily positioned in one direction, the risk of a squeeze is elevated. Scale down when crowd positioning is extreme; scale up when positioning is neutral and your directional signal is strong.

Macro Overlay

Divergence data is best used for portfolio-level decisions rather than individual trade entries. When DXY-BTC divergence is high, reduce overall crypto exposure. When VIX is elevated and crypto has not corrected, tighten stops across the board. These are the decisions that protect capital during regime transitions.

Pricing Context

The free tier gives you the regime classification endpoint and the market overview — enough to implement a pre-trade filter today, with no credit card required. Rate limit: 10 requests per minute, 500 per day.

Pro unlocks everything: all strategy signals, crowd positioning, macro divergences, the full intelligence brief, and webhooks for push-based delivery. The cost is $49/mo, or $39/mo on an annual plan.

For context on what you would pay elsewhere: Glassnode Advanced runs $799/mo and covers on-chain only — no signals, no regime classification, no macro. Nansen starts at $150/mo and focuses on wallet analytics, not trading signals. Building the equivalent pipeline yourself means engineering time plus $200+/mo minimum in data feed subscriptions (CoinGlass alone is $35/mo for the data Regime already aggregates).

At $49/mo, Regime costs less than a single data feed and delivers the finished intelligence layer your bot actually needs.

Get Started

The regime endpoint is free. No signup required to test it. For the full signal suite, registration takes 30 seconds and the interactive playground fires every endpoint automatically so you can see exactly what the responses look like before writing any integration code.

Try it: getregime.com/quickstart — the interactive playground auto-fires every endpoint.

Try Regime Intelligence

Regime is a real-time crypto market regime detection API. One endpoint tells you if the market is bull, bear, or chop — so your bot only trades when conditions match your strategy.

Free API access → | See pricing → | API docs →

One API Call Replaces 9 Crypto Data Sources — Here's How

Gunnar Thorderson — Sun, 19 Jul 2026 09:00:10 +0000

One API Call Replaces 9 Crypto Data Sources — Here's How

If you've built a crypto trading system that does anything beyond basic spot trading, you know the real work isn't the strategy. It's the data pipeline.

You start with Binance for price data. Then you need funding rates, so you add CoinGlass. Then you want macro context, so you pull from FRED and Yahoo Finance. Then someone tells you Fear and Greed is a useful contrary indicator, so you wire up Alternative.me. Before you know it, you're maintaining nine separate API integrations, each with its own auth scheme, rate limits, response format, and failure modes.

This is what we call the DIY tax. And it's costing you more than you think.

The DIY Tax

Here's what a serious crypto trading infrastructure typically requires:

Binance — Price, volume, order book depth, candlestick data. Free tier is generous, but you're dealing with websocket management, reconnection logic, and weight-based rate limits that silently change.

CoinGecko — Market cap, dominance percentages, data on 15,000+ coins. Free tier caps at 30 requests per minute. Their response format nests data differently depending on the endpoint.

CoinGlass — Funding rates, open interest, liquidation data. $35/month. Required if you trade futures with any edge at all.

DeFiLlama — Total Value Locked across DeFi protocols, stablecoin supply metrics. Free, but the API structure changes periodically without notice.

Alternative.me — The Fear and Greed Index. Simple endpoint, but it returns data in a format that requires transformation to be useful alongside everything else.

FRED (Federal Reserve Economic Data) — DXY (dollar index), Fed funds rate, 10-year treasury yield. Free, but responses come in a verbose XML/JSON format designed for economists, not trading systems.

Yahoo Finance — S&P 500, Gold, VIX. Unofficial API that breaks regularly. Every Yahoo Finance wrapper library has a graveyard of GitHub issues about sudden schema changes.

Hyperliquid — Live funding rates, open interest, mark prices across perpetual markets. Free, relatively stable, but another integration to maintain.

On-chain data — Wallet flows, exchange balances, whale movements. Varies wildly by provider and chain. Helius, Alchemy, Dune — pick your complexity.

Each source has different authentication (API keys, OAuth, no auth, session tokens). Each has different rate limiting (per-second, per-minute, weight-based, IP-based). Each returns data in a different shape. Each fails in its own way — timeouts, 429s, empty responses, schema changes, deprecations.

The realistic cost: $35+ per month in paid API subscriptions, plus 50 to 100 hours of engineering to build the initial pipeline, plus ongoing maintenance as providers change their APIs. That maintenance never ends.

What Regime Does Instead

Regime polls all 9 data sources every 60 seconds. It normalizes every data point into a consistent format. It combines them into 10 weighted signals. It classifies the current market into bull, bear, or chop. And it exposes everything through a single REST API.

You make one call. You get the answer.

No API key juggling. No rate limit arithmetic. No data normalization code. No 3 AM alerts because Yahoo Finance changed their response schema again.

The Data Flow

Here's what happens every 60 seconds inside the Regime pipeline:

Raw data collection. Nine sources are polled in parallel. Each has its own adapter that handles auth, retries, and error recovery. If one source fails, the system continues with the remaining eight — graceful degradation, not a crash.

Signal normalization. Each raw data point gets transformed to a -1 to +1 scale. Funding rates, Fear and Greed, DXY movement, TVL changes, order book imbalance — they all become comparable numbers on the same scale.

Weighted aggregation. The 10 normalized signals are combined using empirically tuned weights. SMA crossover carries 20% weight as the primary trend signal. Others contribute 8-12% each. The weights reflect months of backtesting against actual regime transitions.

Regime classification. The weighted composite score determines the regime. Above +0.3 is BULL. Below -0.3 is BEAR. Between is CHOP. Simple thresholds, but the signal quality behind them is what matters.

HMM validation. A Hidden Markov Model runs as a second opinion on the regime classification. It models market states as a probabilistic sequence, catching transitions that the threshold-based classifier might lag on. When the two disagree, the API tells you — that disagreement itself is a signal.

What You Get in One Call

Free tier — no auth required:

curl https://getregime.com/api/v1/market/overview

Returns BTC price, ETH price, Fear and Greed index, current regime classification, total DeFi TVL, BTC dominance, and total market cap. Updated every 60 seconds. This single endpoint replaces calls to Binance, CoinGecko, Alternative.me, and DeFiLlama.

Pro tier — full intelligence synthesis:

curl -H "Authorization: Bearer YOUR_API_KEY" \
  https://getregime.com/api/v1/intelligence/brief

Returns a complete synthesis of all 9 data sources: regime classification with confidence score, crowd positioning analysis (funding bias, liquidation imbalance), macro divergences (DXY-BTC, VIX-crypto), risk assessment, and actionable context. One call, one response, everything you need to make a decision.

Additional Pro endpoints give you granular access to futures data, macro indicators, order book depth, strategy signals, and regime history — all through the same API key, the same base URL, the same consistent response format.

Cost Comparison

Approach	Monthly Cost	Setup Time	Maintenance
DIY (9 APIs)	$35+ in APIs + engineering	50-100 hours	Ongoing
Glassnode + CoinGecko Pro	$928/mo	20 hours	Moderate
Regime Pro	$49/mo	5 minutes	Zero

The Glassnode comparison is worth noting. Their Advanced plan is $799/month. CoinGecko Pro is $129/month. Together that's $928/month and you still need to build the aggregation layer yourself. You're paying nearly $1,000/month for raw data that you then need to normalize, weight, and interpret.

Regime does the aggregation, normalization, weighting, and classification for you. $49/month. The infrastructure is the product.

The Data Moat

Regime has been running continuously since March 2, 2026. That's 8,100+ market snapshots — one every 60 seconds, around the clock. Every snapshot records the raw data from all 9 sources, every normalized signal value, every regime classification, every confidence score.

This isn't just current data. It's a historical record of every regime transition, every signal divergence, every moment the HMM disagreed with the threshold classifier. That history grows every minute, and it's what makes backtesting against real regime data possible.

When you query the regime history endpoint, you're not getting a model's guess about what past regimes looked like. You're getting actual classifications computed from real data at the time they happened. That distinction matters when you're building strategies that depend on regime awareness.

Get Started

Try the overview endpoint right now. It's free, no authentication required:

curl https://getregime.com/api/v1/market/overview

If you're currently maintaining your own multi-source data pipeline, you already know the pain this solves. If you're about to build one, save yourself the 100 hours.

The API documentation covers every endpoint, and the free tier gives you enough to evaluate whether the data quality meets your needs before committing to Pro.

Stop maintaining data pipelines. Start building strategies.

Try Regime Intelligence

Regime is a real-time crypto market regime detection API. One endpoint tells you if the market is bull, bear, or chop — so your bot only trades when conditions match your strategy.

Free API access → | See pricing → | API docs →