MagicTradeBot v6.0 — RedisMarketBridge Integration Guide

Real-time market data. Zero per-bot API calls. No rate limit risk.

Table of Contents

1. Introduction
2. Architecture Overview
3. Prerequisites
4. Installation & Setup
5. Enabling Redis in MagicTradeBot
6. Running Multiple Bots
7. Redis Key Schema
8. Deployment Patterns
9. Signal Engine Configuration
10. Troubleshooting
11. Upgrading to Pro
12. Quick Reference

1. Introduction

MagicTradeBot v6.0 introduces native Redis integration, enabling a fundamentally new architecture for running multiple bots simultaneously. By connecting to RedisMarketBridge as a shared market data layer, every bot in your fleet reads live market data from Redis rather than hitting exchange APIs directly — regardless of how many bots are running.

Why This Matters

Without Redis: 10 bots on Binance = 10× rate limit consumption. 100 bots = near-certain throttling.

With Redis: 1,000 bots on Binance = the same 1 rate-limit-slot used by RedisMarketBridge. Your bots are invisible to the exchange.

RedisMarketBridge is the single source of truth. All bots consume data from it in microseconds — no network round trips, no API keys needed per bot.

1.1 What is RedisMarketBridge?

RedisMarketBridge is a self-hosted, open source (MIT) market data pipeline that:

• Connects to up to 12 exchanges simultaneously using one dedicated parallel worker per exchange
• Fetches and normalises market data: tickers, klines, funding rates, order book movement, cross-exchange spreads
• Processes data through a 6-phase pipeline — from raw tick to structured, TTL-managed signal
• Writes everything to Redis using a consistent key schema readable by any language
• Computes signals — RSI, MACD, Bollinger Bands, VWAP, CVD, OFI — and stores them alongside raw data

1.2 How MagicTradeBot v6.0 Uses It

When Redis mode is enabled in MagicTradeBot, each bot instance switches its data-fetching strategy:

The trading logic, signal processing, order placement, and risk management are unchanged. Only the data ingestion layer changes — and the performance difference is dramatic.

2. Architecture Overview

2.1 The Full Stack

Binance API   ──→  RMB worker thread  ──┐
Bybit API     ──→  RMB worker thread  ──┤
Gate.io API   ──→  RMB worker thread  ──┤
HTX API       ──→  RMB worker thread  ──┤  →  Redis  (single source of truth)
KuCoin API    ──→  RMB worker thread  ──┤
Kraken API    ──→  RMB worker thread  ──┤
… 12 total    ──→  RMB worker thread  ──┘
                                             ↓
                          ┌──────────────────────────────┐
                          │  MagicTradeBot Bot 1          │
                          │  MagicTradeBot Bot 2          │  All read from Redis
                          │  MagicTradeBot Bot 3          │  Zero direct exchange calls
                          │  MagicTradeBot Bot N  (∞)     │
                          └──────────────────────────────┘

All bots read from Redis. Zero direct exchange API calls from bot code. The exchange only talks to RedisMarketBridge.

2.2 6-Phase Pipeline

RedisMarketBridge processes market data through six sequential phases before it reaches your bots:

3. Prerequisites

3.1 Required Software

3.2 Exchange API Keys

RedisMarketBridge uses public endpoints only for market data — no API keys are required for tickers, klines, or funding rates. API keys are optional and only needed for:

• Higher rate limits on some exchanges (Binance, OKX)
• Private data access (not used in the market data pipeline)
• Future trading features if enabled

⚠️ IMPORTANT — Bot API Keys

MagicTradeBot still requires exchange API keys for order placement. Only the market data ingestion is offloaded to RedisMarketBridge. Your bot API keys are used exclusively for placing, monitoring, and cancelling orders.

4. Installation & Setup

4.1 Step 1 — Start Redis

The simplest way is Docker Compose. Create docker-compose.yml:

version: '3.8'
services:
  redis:
    image: redis:7-alpine
    container_name: rmb-redis
    ports:
      - "6379:6379"
    volumes:
      - redis-data:/data
    command: redis-server --maxmemory 2gb --maxmemory-policy allkeys-lru
    restart: unless-stopped

volumes:
  redis-data:

docker compose up -d redis
# Verify:
redis-cli ping   # → PONG

4.2 Step 2 — Download RedisMarketBridge

Free tier (open source, MIT):

git clone https://github.com/magictradebot/redis-market-bridge
cd redis-market-bridge
cargo build --release
# Binary: ./target/release/redis-market-bridge

Pro tier (binary download):

After purchasing a Pro license at magictradebot.com, download the pre-built binary for your OS. No build step required. The same binary works for Free features — your license key activates Pro features instantly.

4.3 Step 3 — Configure RedisMarketBridge

All configuration lives in the settings/ directory:

connection.yaml — Redis Connection

Redis:
  Host: "127.0.0.1"    # or your Redis server IP
  Port: 6379
  Password: ""          # Set if Redis auth is enabled
  TLS: false
  Database: 0
  PoolSize: 20          # Increase for high bot count

exchanges.yaml — Exchange Configuration

Uncomment each exchange you want to enable. All market data endpoints are public — API keys are optional:

Exchanges:

  - Name: "binance"
    Credentials:
      ApiKey: ""        # Optional — for higher rate limits
      ApiSecret: ""
    Proxy:
      Enabled: false

  - Name: "bybit"
    Credentials:
      ApiKey: ""
      ApiSecret: ""

  # Pro tier — uncomment to activate:
  #- Name: "okx"
  #  Credentials:
  #    ApiKey: ""
  #    ApiSecret: ""
  #    Passphrase: ""   # REQUIRED for OKX

  #- Name: "gateio"
  #- Name: "htx"
  #- Name: "kucoin"    # Passphrase required
  #- Name: "kraken"
  #- Name: "bingx"
  #- Name: "phemex"
  #- Name: "mexc"      # ⚠️ Caution: re-launched March 2026 — monitor carefully
  #- Name: "hyperliquid"

⚠️ MEXC Caution

MEXC futures API was offline from 2022–2026 and relaunched in March 2026. RedisMarketBridge will display a warning on boot and on every MEXC data write. Monitor MEXC data carefully during the initial stabilisation period.

application.yaml — Engine Mode

Engine: "Both"   # MarketBridge | SignalBridge | Both

License:
  Key: ""         # Your Pro license key (leave blank for Free tier)

General:
  DebugMode: false
  RenderDashboard: true

4.4 Step 4 — Start RedisMarketBridge

# Start the bridge:
./redis-market-bridge

# Or with Docker Compose — add to docker-compose.yml:
# services:
#   rmb:
#     image: magictradebot/redis-market-bridge:latest
#     volumes:
#       - ./settings:/app/settings
#     depends_on: [redis]
#     restart: unless-stopped

Expected startup output:

[RMB] Starting RedisMarketBridge v1.0
[RMB] Engine mode: Both
[RMB] Redis: 127.0.0.1:6379 connected ✓
[RMB] Spawning worker: binance
[RMB] Spawning worker: bybit
[RMB] Spawning worker: bitget
[Phase 1] Symbol sync: BINANCE=665 BYBIT=542 BITGET=544
[Phase 1] Symbol sync complete — 1,751 symbols in Redis
[Phase 3] Tick data streaming — cycle 5s
[Phase 6] Signal engine active — RSI MACD BB VWAP

5. Enabling Redis in MagicTradeBot

5.1 Redis Configuration

Open your MagicTradeBot configuration and locate the Redis section (new in v6.0):

# MagicTradeBot v6.0 — settings/connection.yaml

Redis:
  Enabled: true                    # Set to true to activate Redis mode
  Host: "127.0.0.1"               # Same Redis instance as RedisMarketBridge
  Port: 6379
  Password: ""
  TLS: false
  Database: 0
  ConnectionPool: 10               # Per bot-instance pool size

  # Fallback behaviour when Redis is unavailable:
  FallbackToDirectApi: true        # Falls back to direct API calls if Redis key missing
  FallbackWarningLog: true         # Logs a warning on each fallback
  FallbackStaleThresholdMs: 30000  # Treat data as stale if older than 30s

5.2 What Changes When Redis is Enabled

✅ Fallback Protection

If a Redis key is missing or expired (e.g. RedisMarketBridge is down), MagicTradeBot automatically falls back to a direct exchange API call for that specific data point. This ensures bots never stop running due to a data layer outage. Set FallbackToDirectApi: false to disable (not recommended in production).

6. Running Multiple Bots

6.1 The Core Advantage

6.2 Single Exchange — Multiple Bots

Running 20 different strategy bots all targeting Binance USDT perpetuals:

# bot-1-btc.yaml  (Long/Short BTC, 15m signal)
Exchange: "binance"
Symbol: "BTCUSDT"
Strategy: "momentum"
Redis:
  Enabled: true
  Host: "127.0.0.1"

# bot-2-eth.yaml  (Long/Short ETH, 30m signal)
Exchange: "binance"
Symbol: "ETHUSDT"
Strategy: "mean_reversion"
Redis:
  Enabled: true
  Host: "127.0.0.1"

# ... repeat for as many bots as needed
# All read from the same Redis — Binance sees ONLY RMB's single connection

6.3 Multi-Exchange — Multiple Bots

Running bots across 5 different exchanges simultaneously. Without Redis this would require managing 5 separate rate limit budgets across all bots. With Redis:

# bot-binance-sol.yaml
Exchange: "binance"
Symbol: "SOLUSDT"
Redis: { Enabled: true, Host: "127.0.0.1" }

# bot-bybit-sol.yaml  (same symbol, different exchange — arb comparison)
Exchange: "bybit"
Symbol: "SOLUSDT"
Redis: { Enabled: true, Host: "127.0.0.1" }

# bot-gateio-arb.yaml  (reads cross-exchange arb signal from Redis)
Exchange: "gateio"
Symbol: "SOLUSDT"
Strategy: "funding_arb"
Redis:
  Enabled: true
  Host: "127.0.0.1"
  UseArbSignals: true       # Read pre-computed arb:signal:SOLUSDT from Redis

💡 Cross-Exchange Arb Bots

ArbEdgeBot (MagicTradeBot’s funding arbitrage module) benefits most from Redis. It reads pre-computed cross-exchange funding gap scores from arb:signal:__top__ — a single key containing the top-N opportunities ranked by spread + momentum + liquidity weight. Zero API calls required.

7. Redis Key Schema

MagicTradeBot reads data from Redis using a consistent key schema written by RedisMarketBridge.

7.1 Key Reference

7.2 Example Redis CLI Inspection

redis-cli

# Check if bridge is writing:
> KEYS tick:binance:*
1) "tick:binance:BTCUSDT"
2) "tick:binance:ETHUSDT"
... 665 results

# Get current BTC price:
> GET tick:binance:BTCUSDT
{"price":67284.1,"vol24h":1842311490,"bid":67283.5,"ask":67284.7}

# Get funding rate for SOLUSDT:
> GET funding:bybit:SOLUSDT
{"rate":-0.00871,"next":1734567890000,"anomaly":true}

# Get RSI for ETHUSDT 30m:
> GET signal:binance:ETHUSDT:30m
{"rsi":42.3,"macd":-12.4,"bb_pct":0.31,"cvd":-184200}

# Get top arb signals (ArbEdgeBot reads this):
> GET arb:signal:__top__
{"count":66,"signals":[{"symbol":"SOLUSDT","score":8.22,...},...]}

# Check TTL on tick data:
> TTL tick:binance:BTCUSDT
12

7.3 Reading from Redis in Bot Code

MagicTradeBot handles all Redis reads internally when Redis.Enabled: true. However, you can also read directly from Redis in custom scripts or dashboards:

# Python
import redis, json

r = redis.Redis(host='127.0.0.1', port=6379)

# Get price
tick = json.loads(r.get('tick:binance:BTCUSDT'))
price = tick['price']

# Get RSI
signal = json.loads(r.get('signal:binance:BTCUSDT:30m'))
rsi = signal['rsi']

# Get top arb opportunities
top = json.loads(r.get('arb:signal:__top__'))
best = top['signals'][0]  # {'symbol': 'SOLUSDT', 'score': 8.22, 'spread': 1.42, ...}

// Rust — ArbEdgeBot integration
let price = get_last_price("binance", "BTCUSDT").await?.unwrap_or(0.0);
let signals: Vec<ArbSignal> = get_top_arb_signals().await?;
let funding_rates = get_all_funding_rates("bybit").await?;

// JavaScript / Node.js
const client = createClient({ url: 'redis://127.0.0.1:6379' });
const tick = JSON.parse(await client.get('tick:binance:BTCUSDT'));
const allPrices = JSON.parse(await client.get('tick:binance:__price__'));
// → { BTCUSDT: 67284.1, ETHUSDT: 3412.0, SOLUSDT: 184.2, ... 665 symbols }

8. Deployment Patterns

8.1 Pattern A — Single Node (Beginner)

Everything on one machine. Best for personal use, testing, or a single-strategy bot fleet.

Machine: 1 VPS (4 CPU, 8GB RAM recommended)

┌─────────────────────────────────────────┐
│  RedisMarketBridge  (Engine: Both)       │  ← Syncs all exchanges in parallel
│  Redis 7.x                               │  ← Shared data store
│  MagicTradeBot Bot 1                     │  ← Reads Redis, places orders
│  MagicTradeBot Bot 2                     │
│  MagicTradeBot Bot N                     │
└─────────────────────────────────────────┘

When to use: Starting out, running fewer than 50 bots, or if simplicity matters more than maximum performance.

8.2 Pattern B — Separated Bridge + Bots (Recommended)

RedisMarketBridge on a data node close to exchange servers, bots on a separate compute node.

Node A (Data — low latency VPS near exchange):
  RedisMarketBridge  (Engine: MarketBridge)
  Redis 7.x

             ←→  (network)  ←→

Node B (Compute — wherever suits your bots):
  MagicTradeBot Bot 1..N
  All connect to Node A's Redis

Recommended node locations:

When to use: Running 50+ bots, or when tick data latency matters for your strategy.

8.3 Pattern C — Distributed (Advanced)

One MarketBridge node per exchange region, a shared Redis cluster, and a dedicated SignalBridge compute node.

Node 1 (Tokyo):          Node 2 (Singapore):      Node 3 (Frankfurt):
  Engine: MarketBridge     Engine: MarketBridge      Engine: MarketBridge
  Exchange: binance         Exchange: bybit            Exchange: kraken, gateio

                ↓                  ↓                       ↓
          Redis Cluster  (shared, replicated across regions)
                               ↓
Node 4 (Compute):    SignalBridge — computes RSI/MACD/CVD/OFI for all symbols
                               ↓
Node 5..N:           MagicTradeBot bot fleet — reads Redis, places orders

📋 Studio License Required

Pattern C requires a Studio license ($79/mo) which allows up to 5 concurrent RedisMarketBridge instances. Each node runs independently — a node failure only affects that exchange’s data, not the entire fleet.

9. Signal Engine Configuration

All signals are configured in settings/signal_engine.yaml. Only applies when Engine: SignalBridge or Engine: Both.

9.1 Available Signals

9.2 Example Configuration

# settings/signal_engine.yaml

rsi:
  enabled: true
  period: 14

macd:
  enabled: true
  fast_period: 12
  slow_period: 26
  signal_period: 9

atr:
  enabled: true
  period: 14

bollinger_bands:
  enabled: true
  bb_period: 20
  bb_deviation: 2.0

vwap:
  enabled: true
  std_dev_multiplier: 2.0

cumulative_volume_delta:
  enabled: true
  period: 10

order_flow_imbalance:
  enabled: true
  period: 5

# Heavy — disable on low-CPU machines or high-frequency nodes:
multi_timeframe_analysis:
  enabled: false
  short_term_period: 10
  medium_term_period: 30
  long_term_period: 50

ichimoku_cloud:
  enabled: false

9.3 Performance Guidelines

• Low CPU machines / 1m interval nodes: Disable OFI, Multi-Timeframe, Ichimoku
• Dedicated SignalBridge node: Enable everything — offload compute from the MarketBridge node
• Minimal config (fastest): RSI + MACD + ATR only — covers most signal-based strategies

10. Troubleshooting

10.1 Redis Keys Are Empty / Bots Report Stale Data

# Check RedisMarketBridge is running:
ps aux | grep redis-market-bridge

# Check Redis connection:
redis-cli ping   # → PONG

# Check if keys exist:
redis-cli KEYS 'tick:binance:*' | wc -l   # Should be 665 for Binance

# Check TTL is healthy:
redis-cli TTL 'tick:binance:BTCUSDT'   # Should be 1–15 (not -2 = missing, not -1 = no TTL)

If keys are missing, check RMB logs with DebugMode: true in application.yaml to see exchange connection errors.

10.2 Bots Still Hitting Exchange API Despite Redis Mode

1. Verify Redis.Enabled: true in MagicTradeBot config
2. Confirm Redis.Host and Redis.Port in MagicTradeBot matches the Redis instance RMB writes to
3. Check FallbackWarningLog: true — if you see fallback warnings, RMB is running but a specific key is missing or expired
4. Confirm exchange names match exactly (case-sensitive: "binance" not "Binance")

10.3 MEXC Data Is Missing or Inconsistent

⚠️ MEXC Known Issue

MEXC futures API was offline 2022–2026 and relaunched March 2026. Data may be unreliable during stabilisation. If you see [MEXC CAUTION] warnings in RMB logs, this is expected behaviour. Consider disabling MEXC in exchanges.yaml until the API proves stable.

10.4 Rate Limit Errors Appearing Despite Redis Mode

• Rate limit errors from order placement are normal — bots still place orders directly. Only data reads are offloaded to Redis.
• If you see rate limits on data reads, it means FallbackToDirectApi triggered repeatedly. Check why RMB is not writing the expected keys.

10.5 KuCoin / Bitget / OKX Passphrase Error

These exchanges require a passphrase in bot credentials for order placement. This is a bot-side trading requirement, unrelated to Redis or RedisMarketBridge. Set the passphrase in each bot’s exchange credentials section — it is separate from the RMB exchanges.yaml credentials (which are optional for public data).

10.6 Health Monitoring

Configure Discord or Telegram alerts in settings/notifications.yaml:

Notifications:
  Discord:
    Enabled: true
    WebhookUrl: "https://discord.com/api/webhooks/YOUR_WEBHOOK_URL"
    AlertOn:
      - ExchangeDisconnect
      - RedisConnectionLost
      - HighLatencyWarning
      - MexcCaution

  Telegram:
    Enabled: false
    BotToken: ""
    ChatId: ""

11. Upgrading to Pro

The Free (3 exchanges, 1,751 symbols) and Pro (12 exchanges, 4,081+ symbols) tiers use the same binary. Upgrading is instant — no reinstall, no config changes beyond the license key.

Steps:

1. Purchase a Pro license at magictradebot.com
2. Receive your license key via email
3. Open settings/license.yaml and set:

License:
  Key: "YOUR-LICENSE-KEY-HERE"

4. Restart RedisMarketBridge
5. Uncomment the additional exchanges in exchanges.yaml
6. Restart RedisMarketBridge again — all 12 exchange workers will spawn

What Pro activates:

• ✅ OKX, Hyperliquid, Gate.io, KuCoin, Kraken, HTX, BingX, Phemex, MEXC
• ✅ 12 parallel exchange workers (each exchange fully independent)
• ✅ 4,081+ USDT perpetual symbols
• ✅ 66 cross-exchange arb pairs (vs 3 in Free tier)
• ✅ Arb signal scoring v2 (spread + funding + liquidity weighted)
• ✅ CVD and OFI signals unlocked
• ✅ Full funding rate coverage across all 12 exchanges

12. Quick Reference

Startup Checklist

• Redis is running and accessible (redis-cli ping → PONG)
• RedisMarketBridge is running and writing keys (redis-cli KEYS 'tick:*')
• MagicTradeBot has Redis.Enabled: true and correct Host/Port
• Bot exchange names match exactly the exchange names in RMB exchanges.yaml
• Bot API keys are set for order placement (separate from RMB credentials)
• FallbackToDirectApi: true set as safety net

Key Commands

# Start Redis
docker compose up -d redis

# Start RedisMarketBridge
./redis-market-bridge

# Verify data is flowing
redis-cli KEYS 'tick:binance:*' | wc -l    # → 665 (Binance free tier)
redis-cli GET 'tick:binance:BTCUSDT'        # → {"price":...}
redis-cli GET 'arb:signal:__top__'          # → {"count":66,"signals":[...]}

# Check TTLs are healthy (should be > 0)
redis-cli TTL 'tick:binance:BTCUSDT'        # → 1–15
redis-cli TTL 'signal:binance:BTCUSDT:30m'  # → 1–300

# Monitor RMB output in real time
redis-cli MONITOR

# Count total keys in Redis
redis-cli DBSIZE

Exchange Tier Summary

Support