One binary. Twelve exchanges synced concurrently. 4,000+ symbols processed through a six-phase pipeline — from raw tick to actionable signal — delivered into Redis for any bot, strategy, or analytics tool in any language.
Discovers and syncs all tradeable futures symbols from each exchange on startup. Stores metadata — min quantity, price precision, tick size, step size. Persists across restarts. Bots load symbols from Redis without ever hitting exchange APIs.
symbols:{exchange}
symbols:{exchange}:{symbol}
Fetches OHLCV candlestick data for multiple intervals (1m, 5m, 15m, 30m, 1h, 4h, 1d). Each key TTL is set to expire precisely at the next candle close — so stale candle data never persists. Bots read pre-processed kline arrays directly, skipping the exchange API entirely.
kline:{exchange}:{symbol}:{interval}
Streams live price data for all symbols every 5 seconds. Three key variants: individual symbol price, all prices aggregated, and a price-only map for fast lookups. 15-second TTL means data auto-expires if the bridge stops — bots never read stale prices from a dead process.
tick:{exchange}:{symbol}
tick:{exchange}:__all__
tick:{exchange}:__price__
Syncs perpetual funding rates across all exchanges every cycle. Computes cross-exchange gaps and flags anomalies where rates diverge significantly. Analytics keys track historical spreads. The arb signal engine reads funding data directly to score opportunities.
funding:{exchange}:{symbol}
funding:{exchange}:__all__
analytics:funding:cross_exchange:spreads
Computes smoothed price movement percentages over rolling time windows. Eliminates tick noise to expose true directional momentum. Also computes market-wide trend as an aggregate — a single key that tells you whether the entire market is moving.
movement:{exchange}:{symbol}:{5m|10m|20m}
movement:{exchange}:market_trend:{window}
Computes technical indicators and arbitrage signals from processed data. Each interval has a dedicated watcher that produces IndicatorResult objects stored per symbol. The arb signal engine reads across all exchanges to produce ranked opportunity lists with confidence scores.
signal:{exchange}:{symbol}:{interval}
arb:signal:{symbol}
arb:signal:__top__
arb:summary
tick:binance:BTCUSDT
funding:bybit:SOLUSDT
arb:signal:__top__
movement:gateio:ETHUSDT:5m
signal:kraken:BTCUSDT:30m
analytics:funding:cross_exchange:spreads
Each exchange runs an isolated async worker via tokio::spawn. All twelve sync concurrently — no blocking, no queue. Data lands in Redis from all sources within the same cycle window.
→ Free tier permits any 2 of these 3 to run simultaneously. Useful for evaluation, prototyping, and small single-exchange bots.
// Read live price from Redis let price = get_last_price("binance", "REDUSDT") .await? .flatten() .unwrap_or(0.0); // Read top arb signals let signals: Vec<ArbSignal> = get_top_signals().await?; println!("Top: {} score={:.2}", signals[0].symbol, signals[0].score); // Read funding rates let rates = get_all_funding_rates("bybit").await?;
import redis, json r = redis.Redis(host='localhost', port=6379) # Read live price — no exchange API needed data = json.loads(r.get('tick:binance:REDUSDT')) print(data['price']) # 0.166200 # Read top arb signals signals = json.loads(r.get('arb:signal:__top__')) for sig in signals[:5]: print(sig['symbol'], sig['score'])
import "github.com/go-redis/redis/v8" rdb := redis.NewClient(&redis.Options{ Addr: "localhost:6379", }) // Funding rate gap — cross exchange arb spreads, _ := rdb.Get(ctx, "analytics:funding:cross_exchange:spreads").Result() // Market trend across all symbols trend, _ := rdb.Get(ctx, "movement:binance:market_trend:5m").Result()
const redis = require('ioredis') const client = new redis(6379, 'localhost') // Subscribe to live tick updates const price = JSON.parse( await client.get('tick:binance:__price__') ) // → { BTCUSDT: 94200, ETHUSDT: 3412, SOLUSDT: 184, ... 4081 symbols } // Arb summary for dashboard widget const summary = JSON.parse( await client.get('arb:summary') )
Feed cross-exchange price and funding data to arbitrage execution bots. Pre-scored opportunity signals eliminate per-cycle compute. Powers ArbEdgeBot v2.
arb:signal:__top__
funding:*:__all__
tick:*:__price__
Replace expensive exchange API calls with Redis reads. Kline data, live prices, and technical signals pre-computed and ready. Powers MagicTradeBot's signal processing layer.
kline:*:*:*
signal:*:*:*
movement:*:*:*
Build real-time market dashboards in any language without touching exchange APIs. Cross-exchange spread analytics, funding rate matrices, market trend visualization.
analytics:*
arb:summary
movement:*:market_trend:*
Test and validate strategy ideas against live structured market data without building exchange connectivity. Read funding rates, spreads, and signal data directly from Redis in Python.
Python
Jupyter
Live data
Deploy one bridge instance to power multiple user bots simultaneously. Each bot reads the same Redis keys — infrastructure costs don't scale with user count.
Multi-tenant
Shared Redis
Any language
Same pipeline architecture, new data sources. Add stocks via Alpaca, forex via OANDA, prediction markets via Polymarket API. Same Redis key schema. Same consumers. Zero reconfiguration.
Stocks
Forex
Prediction markets
For evaluating the pipeline on real data. Connect up to 2 exchanges. Same binary, no time limit.
All 12 exchanges in parallel. License key activates instantly — same binary, no reinstall. Included with any MagicTradeBot Pro license.
Multiple deployment nodes. Run one bridge per region for minimum latency. Shared Redis, separate bridges, team support.
settings/bridge.yaml.
Run on your own server. API keys never leave your infrastructure. No rate limits, no SaaS gateway. Start with the free tier on two exchanges — graduate to twelve when you're ready.