Advanced Risk Management for Freqtrade: Integrating Real-Time Market Awareness

Freqtrade is a popular open-source cryptocurrency trading bot framework. It gives you solid tools for strategy development, backtesting, and running automated trading strategies live – and it does a very good job of evaluating individual trade entries and exits.

I’ve used Freqtrade extensively, both for testing ideas and for running strategies live.

One thing I kept running into, though, was that while Freqtrade is very good at answering one question:

“Is this a valid entry signal right now?”

…it doesn’t really answer a different, higher-level one:

“Is this a market worth trading at all right now?”

If you’ve run Freqtrade strategies with real money, you’ve probably seen the same pattern: strategies that look perfectly reasonable in backtests, with sensible entry logic and risk controls, can still bleed during periods of high volatility, regime shifts, or market-wide panic – even when individual entries look fine in isolation.

That gap is what led me to experiment with a separate market-level risk layer, which eventually became Remora.

Rather than changing strategy logic or adding yet another indicator, Remora sits outside the strategy and provides a market-level risk assessment – answering whether current conditions are historically safe or risky to trade, regardless of what your entry signals are doing.

Importantly, this is an additive layer – your strategy logic and entry signals remain unchanged.

This article walks through how that works, how to integrate it into Freqtrade safely, and how to validate its impact using reproducible backtests.

What This Article Covers

• Why market regime risk matters for Freqtrade strategies
• What Remora does (at a high level)
• How to integrate it safely without breaking your strategy
• How to validate its impact using reproducible backtests

Who This Is For (And Who It Isn’t)

This is likely useful if you:

• Run live Freqtrade bots with real capital
• Care about drawdowns and regime risk, not just backtest curves
• Want a fail-safe, auditable risk layer
• Prefer transparent systems over black-box signals

This is probably not useful if you:

• Want a plug-and-play “buy/sell” signal
• Optimise single backtests rather than live behaviour
• Expect risk filters to magically fix bad strategies

Part 1: The Missing Layer in Most Freqtrade Strategies

Market conditions aren’t always tradable. Periods of extreme volatility, panic regimes, bear markets, and negative sentiment cascades can turn otherwise solid strategies into consistent losers – even when individual entries look fine in isolation.

Typical Freqtrade risk controls (position sizing, stop-losses, portfolio exposure) protect individual trades, but they don’t address market regime risk – the question of whether current market conditions are fundamentally safe to trade in at all.

Part 2: Remora – Market-Wide Risk as a Service

Remora is a standalone market-risk engine designed to sit outside your strategy logic.

Instead of changing how your strategy finds entries, Remora answers one question:

“Are current market conditions safe to trade?”

Results at a Glance (Why This Matters)

Before diving into implementation details, it’s useful to see what this approach looks like in practice.

Across 6 years of data (2020-2025), 4 different strategies, and 20 backtests:

• 90% of tests improved performance (18 out of 20)
• +1.54% average profit improvement
• +1.55% average drawdown reduction
• 4.3% of trades filtered (adaptive – increases to 16-19% during bear markets)
• Strongest impact during bear markets (2022 saw 16-19% filtering during crashes)

All results are fully reproducible using an open-source backtesting framework (details later).

Core Design Principles

• Fail-open by default: If Remora is unavailable, your bot continues trading normally.
• Transparent decisions: Every response includes human-readable reasoning.
• Multi-source aggregation: Dozens of signals with redundancy and failover.
• Low-latency: Designed for synchronous use inside live trading loops.
• No lock-in: Simple HTTP API. Remove it by deleting a few lines of code.

Data Aggregation Strategy (High-Level)

Rather than relying on a single indicator, Remora combines multiple signal classes:

Technical & Market Structure:

• Volatility metrics (realised, model-based)
• Momentum indicators
• Regime classification (bull / bear / choppy / panic)
• Volume and market structure signals

Sentiment & Macro:

• News sentiment (multi-source)
• Fear & Greed Index
• Funding rates and liquidations
• BTC dominance
• Macro correlations (e.g. VIX, DXY)

Each signal type has multiple providers. If one source fails or becomes stale, others continue supplying data.

The output is:

• safe_to_trade (boolean)
• risk_score (0-1)
• market regime
• volatility metrics
• clear textual reasoning

Part 3: Freqtrade Integration (Minimal & Reversible)

Integration uses Freqtrade’s confirm_trade_entry hook.

You do not modify your strategy’s entry logic – you simply gate entries at the final step.

Step-by-Step Integration

Here’s exactly what to add to your existing Freqtrade strategy. The code is color-coded: gray shows your existing code, green shows the new Remora integration code.

Step 0: Set Your API Key

Before running your strategy, set the environment variable:

Get your free API key at remora-ai.com/signup.php

Step 1: Add Remora to Your Strategy

Insert the green code blocks into your existing strategy file exactly as shown:

class MyStrategy(IStrategy):
    # ----- EXISTING STRATEGY LOGIC -----
    def populate_entry_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
        pair = metadata['pair']
        
        # Your existing entry conditions...
        # dataframe.loc[:, 'enter_long'] = 1  # example existing logic

        # ----- REMORA CHECK -----
        if not self.confirm_trade_entry(pair):
            dataframe.loc[:, 'enter_long'] = 0  # REMORA: Skip high-risk trades

        return dataframe

    # ----- ADD THIS NEW METHOD -----
    def confirm_trade_entry(self, pair: str, **kwargs) -> bool:
        import os
        import requests
        api_key = os.getenv("REMORA_API_KEY")
        headers = {"Authorization": f"Bearer {api_key}"} if api_key else {}
        
        try:
            r = requests.get(
                "https://remora-ai.com/api/v1/risk",
                params={"pair": pair},
                headers=headers,
                timeout=2.0
            )
            return r.json().get("safe_to_trade", True)  # REMORA: Block entry if market is high-risk
        except Exception:
            return True  # REMORA: Fail-open

Removing Remora is as simple as deleting these lines. No lock-in, fully transparent.

Pair-Specific vs Market-Wide Risk

You can query Remora in two modes:

Pair-specific:

Market-wide (global trade gating):

Many users start with market-wide gating to reduce API calls and complexity.

What the API Returns

This allows debugging blocked trades, auditing decisions, custom logic layered on top, and strategy-specific thresholds.

Part 4: Backtesting & Validation (Reproducible)

Live APIs don’t work in historical backtests – so Remora includes an open-source backtesting framework that reconstructs historical risk signals using the same logic as production.

Repository: github.com/DonaldSimpson/remora-backtests

What It Provides

• Historical signal reconstruction
• Baseline vs Remora-filtered comparisons
• Multiple strategy types
• Consistent metrics and visualisations

What It Shows

• Improvements are not strategy-specific
• Filtering increases during crashes
• Small trade suppression can meaningfully reduce drawdowns
• Performance gains come from avoiding bad periods, not over-trading

You’re encouraged to run this yourself and independently verify the impact on your own strategies.

Here’s what comprehensive backtesting across 6 years (2020-2025), 4 different strategies, and 20 test cases has proven:

Overall Performance Improvements

Financial Impact by Account Size

Based on average improvements, here’s the financial benefit on different account sizes:

What These Numbers Mean

• 4.3% Trade Filtering: Remora prevents trades during dangerous market periods. This is adaptive – during the 2022 bear market, filtering increased to 16-19%, showing Remora becomes more protective when markets are most dangerous.
• +1.54% Profit Improvement: By avoiding bad trades during high-risk periods, strategies show consistent profit improvements. 90% of tests (18 out of 20) showed improvement.
• +1.55% Drawdown Reduction: Less maximum loss during unfavorable periods. This is critical for risk management and capital preservation.
• Best During Crashes: Remora is most effective during bear markets and crashes (2022 showed 16-19% filtering), exactly when you need protection most.

Part 5: Production & Advanced Use

Always fail-open:

Log decisions:

Reduce API load:

• Cache responses (e.g. 30s)
• Use market-wide checks
• Upgrade tier only if needed

Advanced Uses (Optional)

• Dynamic position sizing based on risk_score
• Strategy-specific risk thresholds
• Regime-based strategy switching
• Trade blocking during macro stress events

These are additive – not required to get value.

Part 6: Technical Implementation Details

Data Pipeline Architecture

Remora’s data pipeline follows a producer-consumer pattern:

1. Data Collection: Multiple scheduled tasks fetch data from various sources (Binance API, CoinGecko, news APIs, etc.)
2. Data Storage: Raw data stored in ClickHouse time-series database
3. Materialized Views: ClickHouse materialized views pre-aggregate data for fast queries
4. Risk Calculation: Python service calculates risk scores using aggregated data
5. Caching: Redis caches risk assessments to reduce database load
6. API Layer: FastAPI serves risk assessments via REST API

ClickHouse Materialized Views

ClickHouse materialized views enable real-time aggregation without query-time computation overhead:

This allows Remora to provide real-time risk assessments with minimal latency, even when processing millions of data points.

Failover & Redundancy

Each data source has multiple providers with automatic failover. This ensures reliable risk assessments even if individual data sources experience outages or rate limiting.

This multi-provider approach ensures:

• High Availability: If one provider fails, others continue providing data
• Rate Limit Resilience: Multiple providers mean you’re not dependent on a single API’s rate limits
• Data Quality: Can validate data across providers and choose the most reliable source
• Graceful Degradation: If all providers for one signal type fail, the risk calculator continues using other available signals (volatility, regime, sentiment, etc.)

In Remora’s implementation, each signal type (Fear & Greed, news sentiment, funding rates, etc.) has multiple providers. If one data source is unavailable, others continue providing information, ensuring the system maintains reliable risk assessments even during external API outages.

Security & Best Practices

• API Key Management: Store API keys in environment variables, never in code
• HTTPS Only: Always use HTTPS for API calls (Remora enforces this)
• Rate Limiting: Respect rate limits to avoid service disruption
• Monitoring: Monitor Remora API response times and error rates
• Fail-Open: Always implement fail-open behaviour – never let Remora block your entire trading system

API Access & Pricing

Remora offers a tiered API access structure designed to accommodate different use cases:

Unauthorized Access (Limited)

• Rate Limit: 60 requests per minute
• Use Case: Testing, development, low-frequency strategies
• Cost: Free – no registration required
• Limitations: Lower rate limits, no historical data access

Registered Users (Free Tier)

• Rate Limit: 300 requests per minute (5x increase)
• Use Case: Production trading, multiple strategies, higher-frequency bots
• Cost: Free – registration required, no credit card needed
• Benefits: Higher rate limits, faster response times, priority support

Pro Tier (Coming Soon)

• Rate Limit: Custom limits based on needs
• Use Case: Professional traders, institutions, high-frequency systems
• Features:
  • Customizable risk thresholds and filtering rules
  • Advanced customization options
  • Historical data API access for backtesting
  • Dedicated support and SLA guarantees
  • White-label options
• Status: Currently in development – contact for early access

Getting Started

To get started with Remora for your Freqtrade strategies:

1. Get API Key: Sign up at remora-ai.com/signup.php (free, no credit card required). Registration gives you 5x higher rate limits (300 req/min vs 60 req/min).
2. Set Environment Variable: export REMORA_API_KEY="your-api-key-here"
3. Add Integration: Add the confirm_trade_entry method to your strategy (see color-coded code examples above)
4. Test: Run a backtest or paper trade to verify integration
5. Validate with Backtests: Use the remora-backtests repository to run your own strategy with and without Remora, independently verifying the impact
6. Monitor: Review logs to see Remora’s risk assessments and reasoning

Conclusion

Market regime risk is one of the most common reasons profitable backtests fail live.

Remora adds a thin, transparent, fail-safe risk layer on top of Freqtrade that helps answer whether current market conditions are safe to trade in. It doesn’t replace your strategy – it protects it.

Resources

• Remora Website – Live service and documentation
• API Documentation – Complete API reference
• Backtest Results – Detailed performance analysis
• Freqtrade Integration Examples – Working code examples
• Freqtrade Documentation – Official Freqtrade docs

About the Author: This article was written as part of building Remora, a production-grade market risk engine for algorithmic trading systems. The system is built using modern Python async frameworks (FastAPI), time-series databases (ClickHouse), and MLOps best practices for real-time data aggregation and risk assessment.

Have questions about integrating Remora with Freqtrade? Found this useful? I’d love to hear your feedback or see your integration examples. Feel free to reach out or share your experiences.