DEV Community: Gunnar Thorderson

BTC SMA 50/200 Crossover Strategy: 2026 Backtest Results

Gunnar Thorderson — Tue, 07 Jul 2026 09:00:12 +0000

BTC SMA 50/200 Crossover Strategy: 2026 Backtest Results

The SMA 50/200 crossover is the most popular crypto trend-following strategy. Here are the actual numbers from backtesting 302K candles.

Raw Results (No Regime Filter)

Asset	Period	Return	Max Drawdown	Win Rate
BTC (daily)	Mar 2023 — Mar 2026	+41%	-52%	42%
ETH (daily)	Mar 2023 — Mar 2026	+41%	-48%	39%
SOL (4h)	Mar 2023 — Mar 2026	+312%	-61%	45%

With Regime Filter

Asset	Return	Max Drawdown	Improvement
BTC	+41%	-31%	-40% drawdown
ETH	+166%	-31%	+305% return
SOL	+586%	-38%	+88% return

The regime filter scales position size by market condition: 100% in bull, 40% in chop, 10% in bear.

The Regime Filter Code

import requests

regime = requests.get("https://getregime.com/api/v1/market/regime").json()
scale = {"bull": 1.0, "chop": 0.4, "bear": 0.1}[regime["regime"]]
position_size = base_size * scale

Key Findings

Stop losses destroy SMA crossover with leverage. 3% SL + 5x = guaranteed stopout from normal volatility.
The crossover flip IS the exit signal. Don't add a stop on top.
Regime filtering matters most for ETH and SOL — BTC gets similar returns but much less drawdown.
SOL on 4h timeframe has the strongest trend-following edge — +586% with regime filter.

Try It

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

Python bot with regime filter: github.com/Thordersonjg/regime-trading-bot

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 →

7 Signals That Confirm a Bitcoin Bear Market (Data-Backed)

Gunnar Thorderson — Tue, 07 Jul 2026 09:00:08 +0000

7 Signals That Confirm a Bitcoin Bear Market

"Is this a bear market?" is the most asked question in crypto. Here are 7 quantitative signals that answer it — no opinions, just data.

Current Status: BEAR at 71% Confidence

As of right now, the Regime classifier reads BEAR with 71% confidence. Here's what's driving that classification:

Signal 1: Death Cross (SMA 50 < SMA 200)

The SMA 50 has crossed below the SMA 200 on the daily chart. This "death cross" is the single strongest bear signal in our classifier (20% weight). The last time BTC had a sustained death cross, it preceded a 65% decline.

Current status: Bearish

Signal 2: Fear & Greed at 10 (Extreme Fear)

The Fear & Greed Index is at 10/100 — deep in "Extreme Fear." While extreme fear can mark bottoms, our data shows it also persists during extended bear markets. Fear below 15 preceded continued bearish regime 85% of the time in our dataset.

Current status: Bearish

Signal 3: Negative Funding Rates

Perpetual futures funding rates have turned negative, meaning shorts are paying longs. This indicates the majority of leveraged traders expect further downside.

Current status: Bearish

Signal 4: Rising BTC Dominance

BTC dominance at 56.5% and rising signals "flight to quality" — capital rotating from alts to BTC, the relative safe haven. This is classic bear market behavior.

Current status: Bearish

Signal 5: Volume Profile Below Average

Current 24h volume is running below the 7-day average, suggesting fading participation. In a true bottom, you'd expect capitulation volume (spikes above average), not slow decay.

Current status: Neutral (not confirming bottom)

Signal 6: DXY Strengthening

The US Dollar Index (DXY) has been strengthening, which historically moves inversely to crypto. A strong dollar is headwind for risk assets.

Current status: Bearish (weak signal, 5% weight)

Signal 7: Volatility Expansion

Short-term volatility (ATR 20) has expanded relative to long-term (ATR 90), indicating a risk event rather than calm accumulation.

Current status: Neutral

What This Means for Traders

With 3 out of 6 signals bearish, 2 neutral, and 1 bullish, the weighted sum produces a BEAR classification at 71% confidence.

Recommended actions:

Reduce long exposure to 10-15% of normal
Don't try to catch the bottom — wait for regime shift
The exit signal is the regime flip, not a price target

Track This Live

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

Get the full signal breakdown with Pro ($49/mo): getregime.com/pricing

Set up regime shift alerts: getregime.com/blog/regime-api-webhook-setup-guide

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 →

Best Crypto Market Data API in 2026: Intelligence vs Raw Data

Gunnar Thorderson — Tue, 07 Jul 2026 05:36:55 +0000

Best Crypto Market Data API in 2026: Intelligence vs Raw Data

The crypto data API market has exploded. In 2024, you had a handful of options. In 2026, there are dozens of providers offering price feeds, on-chain analytics, derivatives data, and social metrics.

But here's what most comparison articles won't tell you: raw data is becoming commoditized. Price data is free from every exchange. Basic market cap data is free from CoinGecko. Volume data is free from multiple aggregators.

The real question isn't "which API has the most data?" It's "which API turns data into decisions?"

This guide compares the five most relevant crypto APIs for developers and traders in 2026, with honest assessments of pricing, data quality, and practical use cases.

The Quick Comparison

Feature	CoinGecko	CoinMarketCap	Glassnode	Nansen	Regime
Primary data	Price, market cap	Price, market cap	On-chain metrics	Wallet labels, flows	Regime classification, intelligence
Free tier	30 req/min	10K calls/mo	Limited metrics	None	500 calls/day
Pro price	$129/mo	$79/mo	$799/mo	$150/mo	$49/mo
Inst. price	$149/mo	$399/mo	$1,799/mo	$1,500/mo	$149/mo
Latency	1-3s	500ms-2s	5-30 min	Minutes	<200ms
Unique value	15K+ coins	CMC rank, listings	SOPR, NUPL, exchange flows	Smart money tracking	Regime state, crowd positioning
Best for	Discovery, portfolio tracking	General market data	On-chain research	Whale watching	Trading decisions, bot filters

CoinGecko: The Data Encyclopedia

CoinGecko is the most comprehensive aggregator. 15,000+ coins, hundreds of exchanges, categories, trending lists, developer stats. If you need to build a portfolio tracker or a coin discovery app, CoinGecko is the default choice.

Strengths: Breadth of coverage. Free tier is generous. Community trust is high. NFT data, exchange data, categories — it's all there.

Weaknesses: Latency is 1-3 seconds on the free tier, which is unusable for real-time trading. Data is aggregated, not raw — you're getting CoinGecko's weighted average, not the actual order book. The Pro API at $129/mo is expensive for what amounts to faster access to the same data. No derivatives data (funding, OI, liquidations). No intelligence layer.

Pricing: Free (30 req/min) | Analyst $129/mo | Pro $149/mo

Verdict: Excellent for discovery and portfolio tracking. Not designed for trading intelligence.

CoinMarketCap: The Legacy Standard

CoinMarketCap has been the default crypto data source since 2013. Every crypto website references CMC rankings. Their API offers price, volume, market cap, and exchange data across thousands of assets.

Strengths: Brand recognition. The CMC rank is an industry standard. Historical data access. Global metrics (total market cap, BTC dominance) are solid.

Weaknesses: Acquired by Binance in 2020, which creates data neutrality questions. Free tier is rate-limited aggressively. Data quality issues with self-reported volume (they've improved, but it's still an issue). No derivatives data, no on-chain data, no intelligence layer. The API documentation is confusing with multiple tiers.

Pricing: Free (10K calls/mo) | Basic $79/mo | Hobbyist $299/mo | Enterprise custom

Verdict: Fine for basic market data. The Binance ownership and data quality issues make it less trustworthy for serious analysis.

Glassnode: The On-Chain Deep Dive

Glassnode is the gold standard for Bitcoin on-chain analytics. SOPR, NUPL, exchange flows, miner metrics, HODL waves — if it happens on-chain, Glassnode tracks it.

Strengths: Unmatched depth of on-chain metrics. Academic rigor. Excellent documentation. Their research reports are genuinely insightful. Metrics like NUPL and SOPR have real predictive value for long-term positioning.

Weaknesses: Expensive — $799/mo for Advanced, $1,799/mo for Professional. Data latency is 5-30 minutes for most metrics, making it unusable for intraday trading. Bitcoin-heavy; altcoin coverage is limited. On-chain data alone doesn't capture sentiment, derivatives positioning, or macro factors. Designed for analysts and researchers, not for bot integration.

Pricing: Free (limited) | Advanced $799/mo | Professional $1,799/mo

Verdict: Best-in-class for on-chain research. Too expensive and too slow for real-time trading systems.

Nansen: The Smart Money Tracker

Nansen labels wallets and tracks on-chain flows. Their core value proposition: see what smart money is doing before the market moves. Token God Mode, wallet profilers, and chain-specific analytics.

Strengths: Wallet labeling is genuinely useful. Smart money alerts can front-run market moves. Multi-chain coverage (Ethereum, Solana, Base, etc.). The UI/dashboard is polished.

Weaknesses: No free tier — you can't evaluate without paying. Starting at $150/mo. The "smart money" signals are noisy; by the time you see a whale accumulating, the information may already be priced in. Latency is minutes, not seconds. No API-first approach — it's primarily a dashboard product with an API bolted on. No regime classification or composite intelligence.

Pricing: No free tier | Standard $150/mo | Enterprise $1,500/mo+

Verdict: Valuable for wallet-level research. Not practical as a real-time trading signal.

Regime: The Intelligence Layer

Regime takes a fundamentally different approach. Instead of giving you raw data and letting you figure out what it means, Regime processes 9 data sources through 10 weighted signals and outputs a market intelligence layer: regime classification, confidence scores, crowd positioning, macro divergences, and actionable risk assessments.

Strengths: Sub-200ms latency. Transparent signal breakdown — you see exactly which signals drive the classification. Derivatives data (funding, OI, liquidations) included via CoinGlass integration. Dedicated Freqtrade endpoint. Webhook alerts on regime transitions. Free tier requires no API key. The intelligence brief endpoint synthesizes regime + crowd + macro + risk into one call.

Weaknesses: Asset coverage is 20 coins (not 15,000 like CoinGecko — but it covers the coins people actually trade). No on-chain metrics at Glassnode's depth. Newer platform with less brand recognition. No historical candle data (use Binance for that — it's free).

Pricing: Free $0 (500 calls/day) | Pro $49/mo (10K calls/day) | Institutional $149/mo (unlimited)

Code Example

# No API key needed — hit it right now
curl -s https://getregime.com/api/v1/market/regime | jq

# Full intelligence brief (Pro tier)
curl -s https://getregime.com/api/v1/intelligence/brief \
  -H "Authorization: Bearer YOUR_API_KEY" | jq

// Using the npm SDK
import { RegimeClient } from 'getregime';
const client = new RegimeClient({ apiKey: 'YOUR_KEY' });
const regime = await client.getRegime();
console.log(regime.regime, regime.confidence);

Verdict: Best for developers building trading systems that need to make decisions, not just display data.

The Intelligence Gap

Here's the core problem with traditional crypto APIs: they give you ingredients and expect you to cook the meal.

CoinGecko gives you price data. Glassnode gives you on-chain metrics. Nansen gives you wallet flows. But turning that into "should I trade right now, and if so, how aggressively?" requires you to:

Ingest data from multiple providers
Normalize and clean it
Build your own composite scoring system
Backtest and tune the weights
Handle outages, rate limits, and data quality issues across all providers
Maintain the system as providers change their APIs

That's months of engineering work. And the output is still just a number you have to interpret.

Regime collapses that entire stack into one endpoint. The /market/regime call returns the regime, the confidence, and the signal breakdown. The /intelligence/brief call adds crowd positioning, macro context, and risk assessment.

How to Choose

Choose CoinGecko if: You need broad market data for a portfolio tracker, discovery app, or market overview page. You don't need real-time data or intelligence.

Choose Glassnode if: You're doing deep on-chain research, writing analyst reports, or building long-term allocation models. You have budget for $800+/mo.

Choose Nansen if: You need wallet-level tracking and smart money flow analysis. You're comfortable with $150/mo minimum and dashboard-first workflows.

Choose Regime if: You're building a trading bot, need regime-aware risk management, or want a single API that tells you "what type of market are we in?" with transparent signal decomposition. You want to start free and scale.

The Stack Play

The smartest developers use Regime alongside other APIs, not instead of them:

Regime + Binance — Intelligence + execution. Regime tells you when and how aggressively to trade. Binance executes.
Regime + CoinGecko — Intelligence + discovery. Regime classifies the market. CoinGecko provides the broad asset universe.
Regime + Glassnode — Intelligence + on-chain depth. Regime provides the real-time filter. Glassnode provides the deep research layer.

The intelligence layer sits on top. The data layer sits beneath. That's the architecture that works.

Get started free: 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 →

Best Crypto APIs for Trading Bots in 2026 (Compared)

Gunnar Thorderson — Tue, 07 Jul 2026 05:36:51 +0000

Best Crypto APIs for Trading Bots in 2026 (Compared)

Building a crypto trading bot requires reliable data. But the crypto API landscape is sprawling — there are dozens of providers, each with different pricing, data coverage, rate limits, and reliability trade-offs.

After building and running production trading bots for over a year, we've used most of the major APIs extensively. This comparison is based on real production experience, not just reading documentation.

We'll cover six APIs that represent the major categories: exchange APIs, aggregators, analytics platforms, and intelligence APIs.

The Comparison Matrix

API	Best For	Free Tier	Pro Price	Latency	Unique Data
Regime	Regime detection, intelligence	30 RPM, 3 assets	$49/mo	<200ms	Regime classification, crowd positioning
Binance	Execution + raw market data	1200 req/min	Free	<50ms	Order book, candles, trades
CoinGecko	Market cap, dominance, discovery	30 req/min	$129/mo	1-3s	15,000+ coins, categories
CryptoCompare	Historical OHLCV	100K calls/mo	$79/mo	200ms	Social stats, exchange grading
Messari	Fundamental research	20 req/min	$299/mo	500ms	Governance, token unlocks
Glassnode	On-chain analytics	Limited	$799/mo	5-30min	SOPR, NUPL, exchange flows

1. Regime (getregime.com) — Intelligence Layer

What it does: Regime is a crypto intelligence API that classifies market conditions into bull, bear, or chop regimes using 10 weighted signals from 9 data sources. It sits on top of raw market data and provides derived intelligence — regime state, crowd positioning, macro divergences, and risk scores.

Best for: Trading bots that need market context, not just price data. If you're building a bot that should trade differently in bull vs bear markets, Regime gives you that classification in a single API call.

Pricing

Tier	Price	RPM	Assets	Key Features
Free	$0	30	BTC/ETH/SOL	Regime, signals, market overview
Pro	$49/mo	100	20+	+ Intelligence, risk scores, alerts
Institutional	$149/mo	1000	All	+ Historical data, webhooks

Code Example

// No API key needed for free tier
const response = await fetch('https://getregime.com/api/v1/market/regime');
const data = await response.json();

console.log(data);
// {
//   regime: 'bear',
//   confidence: 0.78,
//   signals: {
//     btcTrend: 'bearish',
//     fearGreed: 28,
//     fundingBias: 'negative',
//     tvlTrend: 'declining',
//     stablecoinDominance: 'rising',
//     volumeProfile: 'below_average'
//   }
// }

import requests

# Market overview — one call, full picture
overview = requests.get('https://getregime.com/api/v1/market/overview').json()
print(f"BTC: ${overview['btc']['price']:,.0f}")
print(f"Regime: {overview['regime']['regime']} ({overview['regime']['confidence']:.0%})")
print(f"Fear & Greed: {overview['fearGreed']}")

Strengths: Only API that provides regime classification. Free tier is genuinely usable. Sub-200ms response times. Combines 8+ data sources into one endpoint so you don't have to manage multiple API keys.

Weaknesses: Newer platform, smaller community. No historical candle data (use Binance for that). Asset coverage focused on majors (BTC, ETH, SOL, top 20).

Verdict: If your bot needs to answer "what kind of market are we in?" before deciding how to trade, Regime is the only API that answers this directly. Use it alongside an exchange API for execution data.

2. Binance API — The Default Exchange API

What it does: Direct exchange access — real-time prices, order book, candles, trades, and order execution. If you're trading on Binance, this is your primary data source.

Best for: Raw market data and trade execution. Every serious bot uses an exchange API as its foundation.

Pricing

Free for all data endpoints. Trading fees (0.1% spot, 0.02% futures) apply to order execution. US users must use Binance.US (binance.us), which has a smaller API surface.

Code Example

import ccxt

exchange = ccxt.binanceus()

# Fetch 4h candles — free, no auth needed
candles = exchange.fetch_ohlcv('BTC/USDT', '4h', limit=500)

# Order book depth
book = exchange.fetch_order_book('BTC/USDT', limit=50)
bid_volume = sum(b[1] for b in book['bids'][:10])
ask_volume = sum(a[1] for a in book['asks'][:10])
print(f"Bid/Ask ratio: {bid_volume/ask_volume:.2f}")

Strengths: Lowest latency (<50ms). Deepest liquidity. Most complete candle history. Free.

Weaknesses: Only Binance data. No cross-exchange aggregation. No derived analytics. US users limited to Binance.US with fewer pairs. Rate limits can be restrictive for multi-pair bots.

Verdict: Every bot needs an exchange API. Binance is the default choice for liquidity and data quality. But it gives you raw ingredients, not cooked meals.

3. CoinGecko API — The Aggregator

What it does: Aggregated market data across 800+ exchanges and 15,000+ coins. Market cap, volume, dominance, trending coins, categories, and historical data.

Best for: Market discovery, portfolio tracking, altcoin research. If you need data on obscure tokens that aren't on Binance, CoinGecko probably has it.

Pricing

Tier	Price	Rate Limit	Key Features
Free	$0	30 req/min	Basic data, 45-day history
Analyst	$129/mo	500 req/min	1-year history, advanced endpoints
Pro	$149/mo	1000 req/min	Full history, on-chain, DEX data

Code Example

import requests

# Top coins by market cap
resp = requests.get('https://api.coingecko.com/api/v3/coins/markets', params={
    'vs_currency': 'usd',
    'order': 'market_cap_desc',
    'per_page': 10,
})
for coin in resp.json():
    print(f"{coin['symbol'].upper()}: ${coin['current_price']:,.2f} "
          f"(24h: {coin['price_change_percentage_24h']:+.1f}%)")

Strengths: Widest coin coverage. Good free tier. Category and trending data useful for discovery. Familiar, well-documented API.

Weaknesses: Data latency is 1-3 seconds (not suitable for execution). Free tier rate limits (30/min) are tight for production bots. Frequent 429 errors under load. Historical data limited on free tier.

Verdict: Great for portfolio dashboards and market scanning. Not suitable as a primary data source for trading bots due to latency and rate limits. We use it as a fallback price source with 10-minute caching.

4. CryptoCompare — Historical Data Specialist

What it does: Historical OHLCV data, real-time streaming, social metrics, and exchange quality scoring. Strong API design with consistent data formatting.

Best for: Backtesting. If you need clean historical candle data across multiple exchanges and timeframes, CryptoCompare has the deepest archive.

Pricing

Tier	Price	Calls/Month	Key Features
Free	$0	100K	Minute/hour/day candles
Pro	$79/mo	500K	All timeframes, social data
Business	$149/mo	5M	Full history, exchange benchmarks

Code Example

const url = 'https://min-api.cryptocompare.com/data/v2/histoday';
const resp = await fetch(`${url}?fsym=BTC&tsym=USD&limit=365&api_key=${API_KEY}`);
const { Data } = await resp.json();

// 365 daily candles for backtesting
const candles = Data.Data.map(c => ({
  time: new Date(c.time * 1000),
  open: c.open,
  high: c.high,
  low: c.low,
  close: c.close,
  volume: c.volumeto,
}));

Strengths: Clean, consistent historical data. Good exchange coverage. Social media sentiment data. Reasonable pricing.

Weaknesses: Not useful for real-time execution. Social data quality varies. API design is older (v2 feels dated compared to newer APIs).

Verdict: Best value for historical backtesting data. If you're running walk-forward optimization across years of data, CryptoCompare is the most cost-effective source.

5. Messari — Fundamental Research

What it does: Token fundamental data — governance proposals, token unlock schedules, protocol metrics, and research reports. More "investment research" than "trading data."

Best for: Longer-term analysis and due diligence. Understanding protocol fundamentals, upcoming catalysts, and supply-side dynamics.

Pricing

Tier	Price	Key Features
Free	$0	Basic metrics, 20 req/min
Pro	$299/mo	Full API, research, screeners
Enterprise	Custom	Custom feeds, priority support

Code Example

import requests

headers = {'x-messari-api-key': 'YOUR_KEY'}
resp = requests.get('https://data.messari.io/api/v1/assets/bitcoin/metrics',
                     headers=headers)
metrics = resp.json()['data']

print(f"Market Cap: ${metrics['marketcap']['current_marketcap_usd']:,.0f}")
print(f"NVT Ratio: {metrics['on_chain_data']['nvt']:.1f}")
print(f"Active Addresses 24h: {metrics['on_chain_data']['active_addresses']:,.0f}")

Strengths: Unique fundamental data not available elsewhere. Token unlock schedules are particularly valuable for positioning ahead of supply events. Research quality is high.

Weaknesses: Expensive for what you get ($299/mo). Not designed for high-frequency data needs. Coverage focused on top 200 assets.

Verdict: Worth it if you're making investment decisions on a weekly+ timeframe. Overkill for an SMA crossover bot. Token unlock data alone can be worth the subscription if you trade those events.

6. Glassnode — On-Chain Analytics

What it does: Deep on-chain analytics — SOPR, NUPL, exchange inflows/outflows, whale movements, miner behavior, and hundreds of other blockchain-native metrics.

Best for: Understanding on-chain behavior that doesn't show up in price data. Are long-term holders accumulating? Are exchanges seeing inflows (sell pressure) or outflows (accumulation)?

Pricing

Tier	Price	Key Features
Free	$0	Limited metrics, daily resolution
Advanced	$799/mo	Full metrics, 1h resolution
Professional	$1,799/mo	API access, real-time, custom

Code Example

import requests

API_KEY = 'YOUR_GLASSNODE_KEY'
resp = requests.get('https://api.glassnode.com/v1/metrics/indicators/sopr', params={
    'a': 'BTC',
    'api_key': API_KEY,
    'i': '24h',  # daily resolution
})

sopr_data = resp.json()
latest = sopr_data[-1]
print(f"SOPR: {latest['v']:.4f}")
print(f"{'Profit-taking' if latest['v'] > 1 else 'Capitulation'} regime")

Strengths: Unique data you literally cannot get anywhere else. SOPR, NUPL, and exchange flow data have genuine predictive value. The gold standard for on-chain analysis.

Weaknesses: Extremely expensive ($799/mo minimum for useful resolution). Data latency is 5-30 minutes. BTC-focused — ETH and other chain coverage is less mature. Free tier is barely usable.

Verdict: If you're managing serious capital ($500K+), the $799/mo is justified. For smaller accounts, the cost doesn't make sense. Consider it once you're consistently profitable and looking for additional edge.

Our Recommended Stack (By Budget)

$0/month — Getting Started

Binance.US API for candles and execution (free)
Regime Free Tier for regime classification (30 RPM)
CoinGecko Free as price fallback (30 req/min)

This stack runs a production SMA crossover bot with regime-aware sizing. It's what we started with.

$49-80/month — Serious Hobbyist

Binance.US API for execution
Regime Pro ($49/mo) for full intelligence suite
CoinGecko Free or CryptoCompare Free for historical data

Pro tier Regime gives you crowd positioning, macro divergences, and 20+ asset coverage. This is the sweet spot for individual traders.

$350-500/month — Semi-Professional

Binance.US API for execution
Regime Institutional ($299/mo) for historical data + webhooks
CryptoCompare Pro ($79/mo) for backtesting data

Institutional Regime tier gives you historical regime data for backtesting and webhooks for event-driven architectures.

$1,000+/month — Professional/Fund

All of the above, plus:
Glassnode Advanced ($799/mo) for on-chain analytics
Messari Pro ($299/mo) for fundamental research

At this budget, you're assembling a Bloomberg-terminal-equivalent for crypto. Each data source adds a layer of market understanding that translates to better sizing and timing.

How to Evaluate an API for Your Bot

Before integrating any API, test these five things:

1. Uptime under load. Hit the API 100 times in 60 seconds. Does it 429? Does it timeout? Does it return stale data?

2. Data freshness. Compare the API's price to a real-time exchange feed. If it's more than 10 seconds behind, it's not suitable for execution decisions.

3. Error handling. What happens when the API is down? Does your bot crash, or does it degrade gracefully? Always implement fallback data sources.

4. Rate limit headroom. If your bot needs 50 calls/minute and the free tier gives you 30, you'll hit limits on busy days. Budget 2x your expected usage.

5. Data consistency. Fetch the same endpoint 10 times. Are the results consistent? Some APIs have eventual consistency issues where different requests return different data.

// Example: Testing API reliability
async function testApiReliability(url: string, requests: number) {
  const results = [];
  for (let i = 0; i < requests; i++) {
    const start = Date.now();
    try {
      const resp = await fetch(url);
      results.push({
        status: resp.status,
        latency: Date.now() - start,
        ok: resp.ok,
      });
    } catch (e) {
      results.push({ status: 0, latency: Date.now() - start, ok: false });
    }
  }

  const avgLatency = results.reduce((s, r) => s + r.latency, 0) / results.length;
  const successRate = results.filter(r => r.ok).length / results.length;
  console.log(`Success: ${(successRate * 100).toFixed(1)}%, Avg latency: ${avgLatency.toFixed(0)}ms`);
}

// Test Regime API
await testApiReliability('https://getregime.com/api/v1/market/regime', 50);

Bottom Line

There's no single "best" crypto API — it depends on what your bot needs. But if we had to pick one API per category:

Execution data: Binance (free, fastest, deepest)
Market intelligence: Regime (only regime detection API, generous free tier)
Historical data: CryptoCompare (cleanest archive, reasonable pricing)
On-chain: Glassnode (unmatched depth, but expensive)
Fundamentals: Messari (token unlocks alone worth it for event traders)

Most bots need an exchange API + one intelligence layer. Start there and add complexity only when you've proven edge with the basics.

Start building with regime-aware intelligence. The free tier at getregime.com/quickstart gives you 30 requests/minute with no API key required — enough to run a production bot on BTC, ETH, and SOL.

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 →

Add a Regime Filter to Any Freqtrade Strategy in 10 Minutes

Gunnar Thorderson — Tue, 09 Jun 2026 09:00:12 +0000

Add a Regime Filter to Any Freqtrade Strategy in 10 Minutes

A regime filter is a single gate you add on top of your existing Freqtrade entry logic: before a trade opens, the bot checks whether the current market regime — bull, bear, or chop — matches the conditions your strategy is built for, and skips the entry if it doesn't. Your Freqtrade bot otherwise runs the same entry logic in every market, which is why strategies that backtest brilliantly blow up live: the backtest period was one regime, and the live period is another.

This guide shows you how to add Regime's market-condition API to any Freqtrade strategy. No complicated setup. No new dependencies beyond requests. Ten minutes of work for a permanent improvement to your bot's risk management — and there's a free, complete strategy file at the end.

Why Your Freqtrade Bot Needs a Regime Filter

Freqtrade's populate_entry_trend function generates buy signals based on technical indicators — RSI, MACD, Bollinger Bands, moving averages, whatever your strategy uses. The problem: those indicators don't know context.

An RSI of 30 means something completely different in a bull market (buying opportunity) versus a bear market (could drop to 15). A MACD crossover in a trending market leads to a profitable trade. The same crossover in chop leads to a whipsaw loss.

Without regime awareness, your bot makes two systematic errors:

Enters trades in hostile regimes — buying breakouts in bear markets, selling dips in bull markets
Uses uniform sizing — risking the same amount in high-confidence trends as in uncertain chop

Both errors compound. Gating entries on regime doesn't change your edge — it just stops your edge from firing when the environment is wrong for it.

The placement trap: don't call the API in `populate_*`

The mistake almost everyone makes first: putting the regime fetch in populate_indicators or populate_entry_trend. Those run vectorized over your whole history — thousands of candles per call, expected to be pure and fast. An HTTP request there either hammers the API thousands of times in a backtest or blocks the bot loop.

The correct place for an external call is confirm_trade_entry — it runs once, on the live bot, at the moment a trade is about to open. Cache the answer for a few minutes so a busy multi-pair bot makes a handful of calls per hour.

The Regime API Endpoint for Freqtrade

Regime provides a dedicated endpoint optimized for Freqtrade bots:

curl -s https://getregime.com/api/v1/freqtrade/regime \
  -H "Authorization: Bearer YOUR_API_KEY" | jq

Response:

{
  "regime": "bear",
  "confidence": 0.72,
  "action": "exit_or_hedge",
  "fear_greed": 31,
  "btc_price": 61240,
  "updated_at": "2026-06-08T14:00:00.000Z"
}

The action field maps directly to Freqtrade behavior:

Action	Regime	What Your Bot Should Do
`full_position`	Bull	Normal operation, full position sizes
`reduce_position`	Chop	Smaller positions, skip marginal setups
`exit_or_hedge`	Bear	Cut risk, tighten stops, sit out longs

This endpoint works with any tier: a free key returns a 15-minute-delayed read (enough to gate a bot trading majors); a Pro key makes it real-time. Grab a key (no card) at getregime.com and set it in your environment — never hard-code it:

export REGIME_API_KEY="your_key_here"

Step 1: Add the Regime Fetcher

Add this to your strategy file. It fetches the current regime and caches it for 5 minutes to stay within rate limits:

import os
import requests
import time
from freqtrade.strategy import IStrategy, DecimalParameter
from freqtrade.persistence import Trade

class MyRegimeFilteredStrategy(IStrategy):
    # --- Regime filter settings ---
    regime_enabled = True
    regime_min_confidence = 0.6
    _regime_cache = None
    _regime_cache_time = 0
    _regime_cache_ttl = 300  # 5 minutes

    def get_regime(self) -> dict:
        """Fetch current market regime with caching."""
        now = time.time()
        if self._regime_cache and (now - self._regime_cache_time) < self._regime_cache_ttl:
            return self._regime_cache

        try:
            resp = requests.get(
                'https://getregime.com/api/v1/freqtrade/regime',
                headers={'Authorization': f"Bearer {os.environ['REGIME_API_KEY']}"},
                timeout=5
            )
            resp.raise_for_status()
            self._regime_cache = resp.json()
            self._regime_cache_time = now
        except Exception as e:
            # On failure, return the last known regime so the bot doesn't freeze
            if self._regime_cache:
                return self._regime_cache
            return {
                'regime': 'unknown',
                'confidence': 0.5,
                'action': 'reduce_position'
            }

        return self._regime_cache

Key design decisions:

5-minute cache — The regime doesn't change every second. Caching avoids burning through rate limits and adds resilience against network blips.
Graceful degradation — If the API is down, the bot uses the last known regime. If there's no cache at all, it defaults to reduce_position (conservative, not frozen).
Timeout — a 5-second timeout prevents the bot from hanging if the API is slow.

Step 2: Filter Entries by Regime

Override confirm_trade_entry to check the regime before every trade:

    def confirm_trade_entry(
        self, pair: str, order_type: str, amount: float,
        rate: float, time_in_force: str, current_time, entry_tag, side, **kwargs
    ) -> bool:
        if not self.regime_enabled:
            return True

        regime = self.get_regime()
        action = regime.get('action', 'reduce_position')
        confidence = regime.get('confidence', 0.5)

        # Block all entries in a bear regime
        if action == 'exit_or_hedge':
            self.log(f"REGIME FILTER: Blocking entry on {pair} — "
                     f"regime={regime['regime']}, action=exit_or_hedge")
            return False

        # Block low-confidence entries
        if confidence < self.regime_min_confidence:
            self.log(f"REGIME FILTER: Blocking entry on {pair} — "
                     f"confidence={confidence:.0%} < {self.regime_min_confidence:.0%}")
            return False

        return True

    def log(self, msg):
        """Simple logger — replace with your logging setup."""
        print(f"[RegimeFilter] {msg}")

That's it. Every entry signal your strategy generates now passes through a regime gate. In bear or low-confidence regimes, the bot sits on its hands instead of churning through losing trades.

Step 3: Scale Position Size by Confidence

For more sophisticated risk management, adjust position size based on regime confidence. Override custom_stake_amount:

    def custom_stake_amount(
        self, current_time, current_rate, proposed_stake,
        min_stake, max_stake, leverage, entry_tag, side, **kwargs
    ) -> float:
        if not self.regime_enabled:
            return proposed_stake

        regime = self.get_regime()
        confidence = regime.get('confidence', 0.5)
        action = regime.get('action', 'reduce_position')

        # Scale stake by confidence
        if action == 'full_position' and confidence >= 0.75:
            scale = 1.0        # Full size in high-confidence bull
        elif action == 'full_position':
            scale = 0.75       # Slightly reduced in moderate bull
        elif action == 'reduce_position':
            scale = 0.5        # Half size in chop
        else:
            scale = 0.25       # Quarter size (shouldn't reach here due to entry filter)

        adjusted = proposed_stake * scale
        adjusted = max(adjusted, min_stake)
        adjusted = min(adjusted, max_stake)

        self.log(f"REGIME SIZE: stake {proposed_stake:.4f} -> "
                 f"{adjusted:.4f} (scale={scale}, regime={regime['regime']}, "
                 f"confidence={confidence:.0%})")

        return adjusted

This creates a smooth risk curve: full size in confident bull markets, half size in chop, quarter size in uncertain conditions. Your bot's equity curve becomes dramatically smoother.

Step 4: Add Regime-Aware Exit Logic (Optional)

You can also use the regime to manage exits. For example, tighten trailing stops when the regime shifts bearish:

    def custom_stoploss(
        self, pair: str, trade: Trade, current_time,
        current_rate: float, current_profit: float, after_fill, **kwargs
    ) -> float:
        regime = self.get_regime()
        action = regime.get('action', 'full_position')

        if action == 'exit_or_hedge' and current_profit > 0.02:
            # In bear regime with profit, tighten stop to lock gains
            return -0.03  # 3% trailing stop
        elif action == 'full_position' and current_profit > 0.05:
            # In bull regime with good profit, give room to run
            return -0.08  # 8% trailing stop

        return -0.10  # Default 10% stop

In bear markets, you lock in profits quickly. In bull markets, you let winners run. Simple logic, massive impact on returns.

Get the complete strategy file

Rather than copy snippets, take the full, runs-out-of-the-box version. Download the free Regime Filter Freqtrade strategy — a complete RegimeFilterStrategy you drop into user_data/strategies/, with the cache, the fail-mode switch, the confidence gate, and a placeholder entry signal you replace with your own. Inherit from it and your existing strategy keeps the regime gate for free.

Pro Tier: Webhook Alerts on Regime Transitions

The endpoint above is enough for filtering. But if you want to be notified the instant the regime changes — so you can manually review positions or trigger automation — the Pro tier ($49/mo) adds webhook support:

# Register a webhook for regime transitions
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-change", "event": "regime_transition"}'

You'll receive a POST whenever the regime shifts (e.g., bull to chop, chop to bear). This is useful for triggering Freqtrade's /forcesell command via its REST API when the market turns hostile.

FAQ

Where do I call the regime API in Freqtrade?
In confirm_trade_entry, not in populate_indicators or populate_entry_trend. Those are vectorized over history and must stay pure and fast; confirm_trade_entry runs once at trade time, which is the right place for an external call.

Does the endpoint need an API key?
Yes — pass Authorization: Bearer YOUR_KEY. A free key works (15-minute-delayed read), and a Pro key makes it real-time. Get one with no card at getregime.com.

Won't this use up my API rate limit?
No, if you cache. One regime read covers every pair for the cache window (default 5 minutes), so a busy bot makes only a few calls per hour — well within the free tier.

What happens if the Regime API is down?
The fetcher returns the last known regime, or a conservative reduce_position default if there's no cache yet — so the bot degrades gracefully instead of freezing.

Does the filter place trades for me?
No. It only blocks entries that don't match the regimes you allow. Your own entry logic still decides what to trade. It's a filter, not a signal generator — and it's informational, not financial advice.

Get the free strategy file and a Regime API key at getregime.com/freqtrade-strategy. Informational tool, not financial advice; regime classification is probabilistic, not a guarantee.

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 Market Regime Detection: A Practical Guide to Bull, Bear, and Chop

Gunnar Thorderson — Tue, 09 Jun 2026 09:00:07 +0000

Crypto Market Regime Detection: A Practical Guide to Bull, Bear, and Chop

Market regime detection is the practice of classifying the current state of a market into a small set of categories — usually bull, bear, or chop — so that a trader or a trading bot can pick the right strategy for current conditions. A momentum strategy that prints in a bull trend bleeds fees in chop. A mean-reversion strategy that works in a range gets run over in a strong trend. The regime is the context that tells you which one you're in.

This guide covers what a regime is, how classification works in practice, the mistakes people make when they build it themselves, and how to wire a regime signal into a bot or dashboard with one API call.

What a "regime" actually means

A regime is a persistent market condition, not a single candle. Three states cover most of what matters:

Bull — price is trending up, higher highs and higher lows, momentum strategies have an edge. Subtypes worth distinguishing: accumulation, breakout, euphoria.
Bear — price is trending down, momentum is negative, risk should be cut. Subtypes: distribution, capitulation, panic.
Chop — no clear trend, price oscillates in a range, trend-following gets whipsawed. Subtypes: ranging, volatile chop.

The reason regime matters more than any single indicator is that the same signal means different things in different regimes. An RSI of 30 is a buy in an uptrend and a "catch a falling knife" in a downtrend. Detect the regime first, and every other decision gets easier.

Why a single indicator isn't enough

Most people reach for one proxy — the 200-day moving average, the Fear & Greed Index, BTC dominance — and call it a regime. Each one is useful and each one is wrong often enough to hurt.

Approach	What it catches	Where it fails
200-day MA	Long, slow trends	Late on transitions; useless in chop
Fear & Greed Index	Sentiment extremes	One signal, no confidence, no breakdown
BTC dominance	Risk-on/risk-off rotation	Silent on absolute direction
Funding rates	Crowd positioning	Noisy; needs context to read

A robust regime read synthesizes many of these instead of betting on one. The trade-off is that synthesis is harder to build and maintain than a single line on a chart.

How multi-signal regime classification works

A practical classifier ingests a spread of signals across different families so that no single noisy input dominates:

Price/trend: moving-average structure, higher-high/lower-low geometry.
Volume & flows: participation, stablecoin flows as dry powder.
Derivatives: funding rates and liquidation imbalance reveal crowd positioning.
Sentiment: Fear & Greed as a contrarian overlay.
Macro: DXY correlation, volatility regime.
On-chain: TVL momentum, dominance.

Each signal is weighted, the weighted votes are combined into a single classification, and — this is the part people skip — the output carries a confidence score. A "bull at 72%" and a "bull at 51%" are different trades. Confidence is what lets you set a threshold: only act when the model is sure enough.

The other thing a good classifier does is detect transitions early. By the time a regime change is obvious on the daily chart, the move is half over. Watching the spread of signals flip — funding cooling, volatility rising, dominance rotating — flags the shift before the price structure confirms it.

Building it yourself vs. calling an API

You can build this. It takes real work, and the work never stops.

What building it yourself involves: wiring up 8–10 data sources (price, derivatives, on-chain, macro), normalizing them, weighting them, tuning the classifier, and then maintaining all of it as APIs change and rate limits bite. The hard part isn't the model — it's the historical dataset. A classifier is only as good as the regime history you can backtest it against, and that history only exists if you've been collecting it continuously for months.

What an API gives you: one call returns the current regime and confidence. Regime is built exactly for this — it synthesizes 10 weighted signals from 9 data sources into a single { regime, confidence } answer, exposes the underlying signals on the Pro tier, and logs every classification to a historical dataset that grows around the clock. At $49/mo for Pro it's a fraction of what the institutional on-chain suites cost, and unlike a dashboard it's API-first, so a bot can branch on it.

GET /api/v1/market/regime
→ { "regime": "bull", "confidence": 0.72, "regimeSubtype": "breakout", ... }

The public regime endpoint needs no key (free tier is 15-minute-delayed); a Pro key makes it real-time and unlocks the per-signal breakdown.

Putting a regime signal to work

Three common patterns:

Entry gate for a bot. Before opening a position, check the regime and skip entries that don't match. (For Freqtrade, there's a free drop-in strategy that does exactly this — see the Freqtrade regime filter guide.)
Risk scaling. Size positions up in a high-confidence bull, cut them in a bear, sit out chop. The confidence score is your dial.
Dashboard / alerting. Surface the regime to a human and fire a webhook on transitions so nobody's caught off guard by a shift.

FAQ

What is market regime detection?
It's the classification of current market conditions into states — typically bull, bear, or chop — so a strategy can adapt to context instead of trading the same way in every environment.

Can I detect regime with just a moving average?
You can approximate a trend with a moving average, but it's late on transitions and blind to chop. A multi-signal classifier with a confidence score is far more reliable because it doesn't depend on any single input.

What's a confidence score and why does it matter?
It's a measure of how strongly the signals agree on the current regime. It lets you set a threshold and only act when the model is confident — for example, skipping any read below 55%.

How do I add regime detection to a trading bot?
Call a regime API in your bot's trade-confirmation step (not the vectorized indicator path), cache the result for a few minutes, and gate entries on the regimes you allow. The Regime API and its Freqtrade endpoint are built for this.

Is regime classification financial advice?
No. It's an informational classification of market conditions and is probabilistic, not a guarantee. It tells you the context; the trading decision is yours.

Want the current regime right now? Check it free at getregime.com — no card required. Informational tool, not financial advice.

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: CHOP at 50% — May 4, 2026

Gunnar Thorderson — Tue, 05 May 2026 09:00:11 +0000

Weekly Regime Recap — May 4, 2026

Current Classification: CHOP (50% confidence)

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

Market Snapshot

Metric	Value
BTC	$80,047
ETH	$2,376
Fear & Greed	40 (Fear)
BTC Dominance	58.6%
Regime	CHOP at 50%

Signal Breakdown

Bullish signals: 2
Bearish signals: 2
Neutral signals: 5

Data Moat Update

15,146 market snapshots collected
493 regime transitions tracked
64 days of continuous monitoring

What This Means for Traders

Chop regime = range-bound. Reduce position sizes by 50%. Mean reversion outperforms momentum. Wait for the regime to shift before adding significant risk.

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 →

Weekly Regime Recap: BEAR at 33% — April 28, 2026

Gunnar Thorderson — Mon, 04 May 2026 09:00:15 +0000

Weekly Regime Recap — April 28, 2026

Current Classification: BEAR (33% confidence)

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

Market Snapshot

Metric	Value
BTC	$76,937
ETH	$2,289
Fear & Greed	33 (Fear)
BTC Dominance	58.1%
Regime	BEAR at 33%

Signal Breakdown

Bullish signals: 2
Bearish signals: 3
Neutral signals: 4

Data Moat Update

11,688 market snapshots collected
486 regime transitions tracked
58 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 33 Fear & Greed (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 →

Weekly Regime Recap: BEAR at 50% — April 22, 2026

Gunnar Thorderson — Mon, 04 May 2026 09:00:11 +0000

Weekly Regime Recap — April 22, 2026

Current Classification: BEAR (50% confidence)

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

Market Snapshot

Metric	Value
BTC	$77,987
ETH	$2,400
Fear & Greed	32 (Fear)
BTC Dominance	57.8%
Regime	BEAR at 50%

Signal Breakdown

Bullish signals: 1
Bearish signals: 3
Neutral signals: 5

Data Moat Update

10,500 market snapshots collected
460 regime transitions tracked
52 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 32 Fear & Greed (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 →

How to Avoid Losses in a Bear Market: A Crypto Trader's Survival Guide

Gunnar Thorderson — Sun, 03 May 2026 09:00:11 +0000

How to Avoid Losses in a Bear Market: A Crypto Trader's Survival Guide

Here's a number most traders don't want to hear: over the last 51 days of continuous market monitoring, 93% of the time the crypto market was classified as bearish. Not choppy. Not neutral. Bearish.

That data comes from 10,000+ market snapshots taken every five minutes by the Regime API, scoring 10 weighted signals across funding rates, crowd sentiment, on-chain flows, macro context, and price structure.

The traders who survived that stretch aren't the ones with the best entry signals. They're the ones who recognized the regime and stopped fighting it.

What a Bear Market Actually Means

A bear market isn't just "prices going down." It's a statistical regime where the market's behavior changes in measurable ways:

Rallies get sold. Every bounce attracts sellers, not buyers. What looks like a reversal becomes a lower high.
Support levels break. Key levels that held for weeks give way because there's no buying pressure underneath.
Funding goes negative. Leveraged traders are positioned short. The crowd expects lower prices, and in bear regimes, the crowd is usually right.
Macro headwinds persist. DXY strength, rising VIX, weak equity correlations — the external environment isn't supporting risk assets.
Volume dries up on bounces. Real buying volume only shows up on capitulation wicks, not on recovery candles.

In a bear regime, strategies that work in bull markets — breakout buying, dip buying, trend following on longs — become systematic losers. The market punishes the same behavior it rewarded three months ago.

Why Most Strategies Fail in Bear Markets

The core problem is simple: most trading strategies are designed for one regime and deployed in all of them.

A long-only momentum strategy that crushed it during a bull run will slowly bleed during a bear market. Not from one catastrophic loss, but from dozens of small ones. Each entry looks reasonable on the chart. The setup triggers, the pattern matches, the indicator fires. But the trade fails because the broader environment doesn't support it.

This is death by a thousand cuts. The strategy's edge disappears, but the signals keep firing, and the bot keeps entering.

The second failure mode is late recognition. By the time a trader manually identifies a bear market — usually after weeks of declining equity — they've already given back most of their bull market gains. Human pattern recognition is too slow for crypto, where regime transitions can happen in 48 hours.

The third failure mode is denial. "This is just a pullback." "It'll bounce from here." "The fundamentals haven't changed." These are stories traders tell themselves while the regime classifier is reading 8 out of 10 signals as bearish.

Five Steps to Protect Your Portfolio

1. Add a Regime Filter to Every Strategy

Before your strategy takes any entry, check the market regime. This is the single highest-impact change you can make:

# Check regime before entering a trade
REGIME=$(curl -s https://getregime.com/api/v1/market/regime | jq -r '.regime')

if [ "$REGIME" = "bear" ]; then
  echo "Bear regime — no new long entries"
  exit 0
fi

A regime filter doesn't need to be complex. The simplest version: if the market is bearish, don't open new long positions. That single rule would have prevented the majority of losses during the 93% bear stretch in our data.

For Freqtrade bots, there's a dedicated endpoint:

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

2. Reduce Position Size — or Go to Cash

Bear markets reward patience, not aggression. If you're going to trade at all during a bear regime:

Cut position size by 50-75%. If you normally risk 2% per trade, drop to 0.5%. The expected value of trades is lower, so your risk per trade should be too.
Move 50-80% to stablecoins. Cash is a position. During the 93% bear period in our data, sitting in USDT outperformed every long-only strategy.
Set a portfolio heat limit. No more than 10-15% of capital at risk during bear regimes, regardless of how good individual setups look.

3. Flip to Mean-Reversion (If You Trade at All)

In bear markets, trend-following dies and mean-reversion works. If you're going to trade:

Short overextended bounces instead of buying dips
Fade moves into resistance, don't buy breakouts
Use tighter take-profits — rallies in bear markets are short-lived

The regime classification tells you which playbook to use. Bull regime = trend-following. Bear regime = mean-reversion or cash. Chop regime = reduce size, widen stops, or sit out.

4. Monitor Regime Transitions, Not Price

Staring at price charts during a bear market leads to emotional trading. Instead, monitor the regime itself.

The Regime API tracks 10 weighted signals:

Funding rates and open interest — Are leveraged traders getting more bearish or is pressure releasing?
Crowd sentiment — Fear & Greed reaching extreme lows (potential exhaustion) or sustained fear?
On-chain flows — Stablecoin supply growing (dry powder) or shrinking?
Macro context — DXY weakening? VIX dropping? SPX recovering?
Price structure — Volume patterns shifting? Volatility compressing?

When these signals start flipping from bearish to neutral, the regime is weakening. That's your signal to prepare — not to trade, but to get ready. The regime transition from bear to chop to bull is where the next opportunity starts.

Pro tier users can set up webhook alerts that fire automatically on regime transitions:

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

5. Use the Bear Market to Build

The most productive thing you can do during a bear market is improve your system. The market isn't rewarding trading, so invest in infrastructure:

Backtest your strategy across different regimes using historical regime data
Build the regime filter you should have had before the bear started
Review your worst trades — how many happened during bear regimes?
Set up automated alerts so you're notified when the regime shifts

The traders who come out of bear markets strongest aren't the ones who traded through it. They're the ones who used the downtime to build better systems.

The Data Behind This Advice

This isn't theoretical. The Regime API has been classifying the market continuously since early March 2026:

10,000+ market snapshots every 5 minutes
460+ regime transitions captured and timestamped
51 days of continuous classification
93% bear regime in the most recent period

Every transition is documented. Every signal score is recorded. The track record page shows live classification accuracy against actual market data.

Bear Markets End

Bear regimes don't last forever. The same 10-signal classifier that kept you out of bad trades will tell you when conditions are shifting. When funding flips positive, sentiment reaches extreme fear (contrarian signal), stablecoin dry powder peaks, and macro headwinds ease — the regime transitions.

The goal isn't to predict the bottom. It's to have a system that tells you when the environment changes, so you can adjust your exposure accordingly.

The Regime API provides real-time crypto market regime detection for traders, funds, and bots. Add a regime filter to your strategy in under 10 minutes — start with the quickstart guide. Free tier available, no credit card 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 →

Best Crypto Trading Bot API in 2026: Binance, CoinGecko, CoinGlass, and Regime Compared

Gunnar Thorderson — Sun, 03 May 2026 09:00:07 +0000

Best Crypto Trading Bot API in 2026: Binance, CoinGecko, CoinGlass, and Regime Compared

Building a crypto trading bot in 2026 means choosing from dozens of APIs. Some give you raw market data. Some give you derivatives analytics. Very few tell you whether you should actually be trading right now.

This guide compares the four APIs that matter most for bot builders: Binance, CoinGecko, CoinGlass, and Regime. Each serves a different layer of the stack, and the best bots use more than one.

The Four Layers of a Trading Bot

Every profitable bot needs four things:

Execution — place orders, manage positions
Market data — prices, volume, order books
Derivatives data — funding rates, open interest, liquidations
Intelligence — regime classification, risk context, macro awareness

Most developers start with layer 1 and never build layer 4. That's why most bots lose money during regime transitions.

API Comparison

Binance API — Execution + Market Data

Binance is the default choice for execution and spot market data. The REST and WebSocket APIs cover order placement, candlestick data, order book depth, and account management.

# Get BTC/USDT 1h candles from Binance
curl "https://api.binance.com/api/v3/klines?symbol=BTCUSDT&interval=1h&limit=5"

Strengths: Deep liquidity, low latency, comprehensive order types, free market data.

Limitations: Binance gives you raw data, not analysis. It won't tell you if the market is in a bear regime where your long-only strategy will bleed out. No funding rate aggregation across exchanges, no regime classification, no macro context.

Pricing: Free for market data. Trading fees 0.1% (lower with BNB).

CoinGecko API — Broad Market Coverage

CoinGecko covers 14,000+ coins with price, market cap, volume, and basic on-chain data. It's the go-to for portfolio tracking and cross-market scanning.

# Get BTC market data from CoinGecko
curl "https://api.coingecko.com/api/v3/coins/bitcoin?localization=false&tickers=false"

Strengths: Massive asset coverage, market cap rankings, exchange volume data, DeFi TVL tracking, free tier with 30 req/min.

Limitations: No derivatives data (funding, OI, liquidations). No real-time streaming. Rate limits are tight on the free tier. Like Binance, it's raw data — no intelligence layer.

Pricing: Free (30 req/min) | Demo $0 (limited) | Analyst $14/mo | Lite $129/mo | Pro $499/mo.

CoinGlass API — Derivatives Intelligence

CoinGlass is the standard for aggregated derivatives data. Funding rates, open interest, liquidation heatmaps, and long/short ratios across every major exchange.

# Get aggregated funding rates from CoinGlass
curl -H "coinglassSecret: YOUR_KEY" \
  "https://open-api-v3.coinglass.com/api/futures/funding-rates-history?symbol=BTC"

Strengths: Aggregated data across 20+ exchanges. Liquidation data, funding rate history, OI trends. Essential for any derivatives-aware strategy.

Limitations: Focused purely on derivatives metrics. No macro data (DXY, VIX, SPX), no regime classification, no sentiment aggregation. You get funding rates but not the context of what those rates mean for your strategy.

Pricing: Free (limited) | Basic $35/mo | Pro $135/mo | Premium $335/mo.

Regime API — The Intelligence Layer

Regime doesn't compete with the APIs above — it completes them. It aggregates data from Binance, CoinGecko, CoinGlass, DeFiLlama, FRED, and Yahoo Finance into a single classification: is the market bullish, bearish, or chopping?

# Get current market regime — no auth required
curl https://getregime.com/api/v1/market/regime

Response:

{
  "regime": "bear",
  "confidence": 72,
  "signal_count": 10,
  "signals": {
    "summary": "8/10 signals bearish"
  }
}

For the full intelligence brief with individual signal breakdowns, crowd positioning, and macro divergences:

# Full intelligence brief (Pro tier)
curl -H "Authorization: Bearer YOUR_API_KEY" \
  https://getregime.com/api/v1/intelligence/brief

Strengths: 10-signal weighted regime classifier updated every 5 minutes. Covers funding rates, crowd sentiment, on-chain flows, macro context, and price structure in a single call. 10,000+ snapshots of historical accuracy data. Purpose-built for bot integration with a dedicated Freqtrade endpoint.

Limitations: Not an execution API — you still need Binance (or similar) to place trades. Focused on BTC/ETH regime (top 20 assets on Pro tier). Not a replacement for raw market data.

Pricing: Free (10 RPM, 15-min delay) | Pro $49/mo (real-time, 120 RPM) | Institutional $149/mo (1000 RPM).

Pricing Comparison

API	Free Tier	Paid From	Best For
Binance	Yes (market data)	Trading fees only	Execution, candles, order books
CoinGecko	30 req/min	$14/mo	Broad market coverage, rankings
CoinGlass	Limited	$35/mo	Aggregated derivatives data
Regime	10 RPM, delayed	$49/mo	Regime classification, risk context

How They Work Together

The best trading bots in 2026 aren't using one API — they're stacking them:

Regime tells the bot whether to trade at all (regime filter)
CoinGlass confirms derivatives positioning (funding bias, OI shifts)
CoinGecko scans for which assets have momentum
Binance executes the trade

Here's what that looks like in practice:

# Step 1: Check regime before doing anything
REGIME=$(curl -s https://getregime.com/api/v1/market/regime | jq -r '.regime')

if [ "$REGIME" = "bear" ]; then
  echo "Bear regime detected — skipping entries, tightening stops"
  exit 0
fi

# Step 2: Check funding rates for positioning context
# Step 3: Scan assets for entry candidates
# Step 4: Execute on Binance

This stack costs $84/mo (Regime Pro + CoinGlass Basic) for the intelligence layers, with free market data from Binance and CoinGecko. Compare that to a single losing trade from running your bot in the wrong regime.

The Bottom Line

Raw market data is a commodity. Every API gives you prices and candles. The edge in 2026 comes from knowing when your strategy works and when it doesn't.

Binance and CoinGecko give you the what. CoinGlass gives you the derivatives context. Regime tells you the when — bull, bear, or chop, with confidence scores and the signals behind the classification.

If your bot doesn't know what regime it's trading in, it's flying blind.

Ready to add regime intelligence to your trading bot? The quickstart guide has code samples in Python, JavaScript, and curl. Start with the free tier — no credit card 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 →

How to Backtest Crypto Strategies by Market Regime (With Real Data)

Gunnar Thorderson — Sat, 02 May 2026 09:00:14 +0000

How to Backtest Crypto Strategies by Market Regime (With Real Data)

Your backtest says Sharpe 2.0. You deploy. It immediately starts losing money.

Sound familiar?

The problem isn't your strategy. It's your backtest. Specifically: it averaged across multiple market regimes, hiding where your edge actually lives.

The Regime Selection Bias Problem

A strategy that returns 40% in bull markets and -20% in bear markets will show a healthy positive backtest if your sample is 60% bull. Deploy it into a bear market and it looks like the signal "decayed."

It didn't decay. You were never testing what you thought you were testing.

Here's what regime-split backtesting reveals:

Strategy	Bull Sharpe	Bear Sharpe	Chop Sharpe	Aggregate Sharpe
SMA 50/200	2.4	-0.3	0.1	1.1
Mean Reversion	0.4	1.8	1.2	1.0
Momentum	3.1	-1.2	-0.5	0.9

The aggregate Sharpe looks similar across strategies. The regime-split view tells a completely different story: SMA crossover only works in trends, mean reversion works everywhere except bull, momentum is great in bull and terrible otherwise.

This is the insight most traders miss.

Step 1: Classify Historical Regimes

Before you can split backtest results by regime, you need regime labels for every historical period.

You have three options:

Option A: Use Regime's Historical API (Recommended)

The /intelligence/regime-history endpoint returns timestamped regime classifications going back to the start of the dataset. Each classification includes regime (bull/bear/chop), subtype, and confidence.

import requests

API_KEY = "your_api_key"
headers = {"Authorization": f"Bearer {API_KEY}"}

# Get regime history
history = requests.get(
    "https://getregime.com/api/v1/intelligence/regime-history",
    headers=headers
).json()

# Each transition includes start time, end time, and average confidence
for transition in history["transitions"]:
    print(f"{transition['regime']} from {transition['started_at']} "
          f"to {transition['ended_at']} "
          f"(confidence: {transition['avg_confidence']:.0%})")

For point-in-time queries (what was the regime at any specific timestamp):

# What regime was it on March 15, 2026?
regime_at = requests.get(
    "https://getregime.com/api/v1/intelligence/regime-at",
    params={"ts": "2026-03-15T00:00:00Z"},
    headers=headers
).json()

print(f"Regime: {regime_at['regime']} ({regime_at['confidence']:.0%})")

Option B: Build Your Own Classifier

If you want to roll your own, the minimum viable regime detector uses 3-4 uncorrelated signals:

Trend: BTC price vs 200-day SMA
Volatility: ATR(20) / ATR(90) ratio
Sentiment: Fear & Greed Index
Macro: DXY direction (optional)

Classify as "bull" when 3+ signals agree bullish, "bear" when 3+ agree bearish, "chop" otherwise. This won't be as accurate as a 10-signal weighted classifier, but it avoids overfitting and is simple to implement.

Option C: Use an HMM

Hidden Markov Models with 2-3 states are popular in academic literature. They work well in-sample but watch out for:

Transition probability drift out-of-sample
Sensitivity to initialization
Overfitting on the training regime distribution

Regime's API includes an HMM endpoint trained on 8,000+ snapshots if you want to compare against your own implementation.

Step 2: Tag Every Trade

Once you have regime labels, tag every trade in your backtest with the regime that was active when the trade was opened.

import pandas as pd

# Your trades dataframe
trades = pd.DataFrame({
    'entry_time': [...],
    'exit_time': [...],
    'pnl_pct': [...],
    'symbol': [...],
})

# Regime transitions from API
transitions = pd.DataFrame(history['transitions'])
transitions['started_at'] = pd.to_datetime(transitions['started_at'], unit='ms')
transitions['ended_at'] = pd.to_datetime(transitions['ended_at'], unit='ms')

def get_regime_at(ts):
    for _, t in transitions.iterrows():
        if t['started_at'] <= ts <= t['ended_at']:
            return t['regime']
    return 'unknown'

trades['regime'] = trades['entry_time'].apply(get_regime_at)

Step 3: Split Performance Metrics

Now calculate Sharpe, win rate, max drawdown, and average trade PnL per regime:

for regime in ['bull', 'bear', 'chop']:
    subset = trades[trades['regime'] == regime]
    if len(subset) == 0:
        continue

    sharpe = subset['pnl_pct'].mean() / subset['pnl_pct'].std() * (252**0.5)
    win_rate = (subset['pnl_pct'] > 0).mean()
    avg_pnl = subset['pnl_pct'].mean()
    max_dd = subset['pnl_pct'].cumsum().cummax() - subset['pnl_pct'].cumsum()

    print(f"\n{regime.upper()}")
    print(f"  Trades: {len(subset)}")
    print(f"  Sharpe: {sharpe:.2f}")
    print(f"  Win Rate: {win_rate:.1%}")
    print(f"  Avg PnL: {avg_pnl:.2%}")
    print(f"  Max DD: {max_dd.max():.2%}")

Step 4: Build a Regime-Aware Strategy

Once you know which regimes your strategy works in, the fix is straightforward:

import requests

def should_trade():
    """Check regime before entering any position."""
    regime = requests.get(
        "https://getregime.com/api/v1/market/regime"
    ).json()

    current = regime['regime']
    confidence = regime['confidence']

    # Only trade in regimes where backtest shows positive Sharpe
    if current == 'chop' and confidence > 0.6:
        return False  # Our strategy loses in chop

    if current == 'bear' and confidence > 0.7:
        return 'short_only'  # Flip to short-only in bear

    return True  # Full trading in bull

# Position sizing by regime
REGIME_SIZE = {
    'bull': 1.0,    # Full size
    'bear': 0.6,    # Reduced
    'chop': 0.4,    # Minimal
}

Real Results: Regime-Following vs Buy-and-Hold

Our track record page shows live, verifiable results from applying regime-based position sizing to BTC:

Regime-following: +7.59%
Buy-and-hold: -1.89%
Alpha: +9.48%

This is from 4,941 market snapshots over 29 days. Not a backtest — real data, real classifications, verifiable on-chain.

Key Takeaways

Never report aggregate backtest Sharpe. Always split by regime. A "Sharpe 2.0" strategy might be a "Sharpe 3.5 in bull, -0.5 in everything else" strategy.
Regime detection doesn't need to be fast — it needs to be right. A 2-day lag on detecting a regime change costs a few percent. A false regime flip costs much more.
Use multiple uncorrelated signals. Single-indicator regime detectors (just RSI, just SMA) overfit. Require supermajority agreement across 4+ signals before reclassifying.
Size by regime, not just signal. Even if you trade in all regimes, reduce position size in regimes where your strategy has low Sharpe.
Track regime-adjusted Sharpe in production. If rolling 30-trade Sharpe drops below 0.5 for the current regime, that's a yellow flag.

Try It

Get regime-classified historical data for your own backtests:

# No auth needed for current regime
curl https://getregime.com/api/v1/market/regime

# Full history requires Pro ($49/mo) or Institutional ($149/mo)
curl -H "Authorization: Bearer YOUR_KEY" \
  https://getregime.com/api/v1/intelligence/regime-history

Free tier: 500 calls/day, regime + market overview. Start here.

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 →

DEV Community: Gunnar Thorderson

BTC SMA 50/200 Crossover Strategy: 2026 Backtest Results

BTC SMA 50/200 Crossover Strategy: 2026 Backtest Results

Raw Results (No Regime Filter)

With Regime Filter

The Regime Filter Code

Key Findings

Try It

Try Regime Intelligence

7 Signals That Confirm a Bitcoin Bear Market (Data-Backed)

7 Signals That Confirm a Bitcoin Bear Market

Current Status: BEAR at 71% Confidence

Signal 1: Death Cross (SMA 50 < SMA 200)

Signal 2: Fear & Greed at 10 (Extreme Fear)

Signal 3: Negative Funding Rates

Signal 4: Rising BTC Dominance

Signal 5: Volume Profile Below Average

Signal 6: DXY Strengthening

Signal 7: Volatility Expansion

What This Means for Traders

Track This Live

Try Regime Intelligence

Best Crypto Market Data API in 2026: Intelligence vs Raw Data

Best Crypto Market Data API in 2026: Intelligence vs Raw Data

The Quick Comparison

CoinGecko: The Data Encyclopedia

CoinMarketCap: The Legacy Standard

Glassnode: The On-Chain Deep Dive

Nansen: The Smart Money Tracker

Regime: The Intelligence Layer

Code Example

The Intelligence Gap

How to Choose

The Stack Play

Try Regime Intelligence

Best Crypto APIs for Trading Bots in 2026 (Compared)

Best Crypto APIs for Trading Bots in 2026 (Compared)

The Comparison Matrix

1. Regime (getregime.com) — Intelligence Layer

Pricing

Code Example

2. Binance API — The Default Exchange API

Pricing

Code Example

3. CoinGecko API — The Aggregator

Pricing

Code Example

4. CryptoCompare — Historical Data Specialist

Pricing

Code Example

5. Messari — Fundamental Research

Pricing

Code Example

6. Glassnode — On-Chain Analytics

Pricing

Code Example

Our Recommended Stack (By Budget)

$0/month — Getting Started

$49-80/month — Serious Hobbyist

$350-500/month — Semi-Professional

$1,000+/month — Professional/Fund

How to Evaluate an API for Your Bot

Bottom Line

Try Regime Intelligence

Add a Regime Filter to Any Freqtrade Strategy in 10 Minutes

Add a Regime Filter to Any Freqtrade Strategy in 10 Minutes

Why Your Freqtrade Bot Needs a Regime Filter

The placement trap: don't call the API in populate_*

The Regime API Endpoint for Freqtrade

Step 1: Add the Regime Fetcher

Step 2: Filter Entries by Regime

Step 3: Scale Position Size by Confidence

Step 4: Add Regime-Aware Exit Logic (Optional)

Get the complete strategy file

Pro Tier: Webhook Alerts on Regime Transitions

FAQ

Try Regime Intelligence

Crypto Market Regime Detection: A Practical Guide to Bull, Bear, and Chop

Crypto Market Regime Detection: A Practical Guide to Bull, Bear, and Chop

What a "regime" actually means

The placement trap: don't call the API in `populate_*`