requirements.txt

ccxt==4.2.0 # Exchange abstraction

pandas==2.2.0 # Data manipulation

requests==2.31.0 # HTTP client

ta==0.11.0 # Technical indicators

import ccxt

import pandas as pd

Initialize exchange connection

exchange = ccxt.binanceus({

'apiKey': 'YOUR_API_KEY',

'secret': 'YOUR_SECRET',

'sandbox': True, # Start with testnet

})

Fetch 4-hour candles

ohlcv = exchange.fetch_ohlcv('BTC/USDT', '4h', limit=200)

df = pd.DataFrame(ohlcv, columns=['ts', 'open', 'high', 'low', 'close', 'volume'])

df['ts'] = pd.to_datetime(df['ts'], unit='ms')

print(df.tail())

TypeScript Setup

mkdir crypto-bot && cd crypto-bot

npm init -y

npm install ccxt node-fetch

npm install -D typescript @types/node tsx

import ccxt from 'ccxt';

const exchange = new ccxt.binanceus({

apiKey: process.env.BINANCE_API_KEY,

secret: process.env.BINANCE_SECRET,

sandbox: true,

});

const candles = await exchange.fetchOHLCV('BTC/USDT', '4h', undefined, 200);

console.log('Latest close:', candles[candles.length - 1][4]);

Step 3: Implement a Basic Strategy

The SMA (Simple Moving Average) crossover is the starting point for most systematic traders. It's not exotic, but when combined with regime awareness and proper sizing, it's remarkably effective.

Strategy: Buy when the 50-period SMA crosses above the 200-period SMA. Sell when it crosses below.

Python Implementation

import pandas as pd

import ta

def sma_crossover_signals(df: pd.DataFrame) -> pd.DataFrame:

"""Generate SMA 50/200 crossover signals."""

df['sma_50'] = ta.trend.sma_indicator(df['close'], window=50)

df['sma_200'] = ta.trend.sma_indicator(df['close'], window=200)

df['signal'] = 0

df.loc[df['sma_50'] > df['sma_200'], 'signal'] = 1 # Long

df.loc[df['sma_50'] < df['sma_200'], 'signal'] = -1 # Short

# Detect crossover points (signal changes)

df['crossover'] = df['signal'].diff().abs() > 0

return df

signals = sma_crossover_signals(df)

latest = signals.iloc[-1]

print(f"Current signal: {'LONG' if latest['signal'] == 1 else 'SHORT'}")

print(f"SMA 50: {latest['sma_50']:.2f}, SMA 200: {latest['sma_200']:.2f}")

TypeScript Implementation

function calculateSMA(closes: number[], period: number): number[] {

const sma: number[] = [];

for (let i = 0; i < closes.length; i++) {

if (i < period - 1) { sma.push(NaN); continue; }

const slice = closes.slice(i - period + 1, i + 1);

sma.push(slice.reduce((a, b) => a + b, 0) / period);

}

return sma;

}

function getSignal(closes: number[]): 'LONG' | 'SHORT' | 'NEUTRAL' {

const sma50 = calculateSMA(closes, 50);

const sma200 = calculateSMA(closes, 200);

const latest50 = sma50[sma50.length - 1];

const latest200 = sma200[sma200.length - 1];

if (isNaN(latest50) || isNaN(latest200)) return 'NEUTRAL';

return latest50 > latest200 ? 'LONG' : 'SHORT';

}

Step 4: Backtest Before You Risk a Single Dollar

The most common mistake new bot builders make is going live without backtesting. A strategy that feels right can easily lose money over hundreds of trades.

def backtest_sma(df: pd.DataFrame) -> dict:

"""Simple SMA crossover backtest."""

signals = sma_crossover_signals(df)

signals['returns'] = signals['close'].pct_change()

signals['strategy_returns'] = signals['signal'].shift(1) * signals['returns']

cumulative = (1 + signals['strategy_returns']).cumprod()

total_return = cumulative.iloc[-1] - 1

# Calculate max drawdown

peak = cumulative.expanding().max()

drawdown = (cumulative - peak) / peak

max_dd = drawdown.min()

return {

'total_return': f"{total_return:.1%}",

'max_drawdown': f"{max_dd:.1%}",

'sharpe': signals['strategy_returns'].mean() / signals['strategy_returns'].std() (252*0.5),

}

results = backtest_sma(df)

print(f"Return: {results['total_return']}, Max DD: {results['max_drawdown']}")

What Our Backtests Show

We backtested SMA 50/200 across 302,000+ candles (March 2023 to March 2026) on BTC, ETH, and SOL:

| Asset | Timeframe | Return | Max Drawdown |

|-------|-----------|--------|--------------|

| SOL | 4h | +586% | -34% |

| ETH | 1d | +166% | -28% |

| BTC | 1d | +41% | -18% |

These returns are with 5x leverage and no stop loss. More on why stop losses hurt in the next section.

Step 5: Add Regime Detection (The Edge)

Here's where your bot goes from "basic tutorial project" to "production trading system." A raw SMA crossover doesn't know if the market is trending or chopping. In a choppy market, it generates false signals that bleed your account through fees and slippage.

Regime detection solves this. By checking the current market regime before acting on a signal, you can:

• Reduce position size in chop (where SMA crossovers whipsaw)

• Go full size in clean trends (where SMA crossovers print money)

• Avoid counter-trend trades (don't short in a high-confidence bull regime)

Using the Regime API

import requests

def get_regime():

"""Fetch current market regime from Regime API."""

resp = requests.get('https://getregime.com/api/v1/market/regime')

data = resp.json()

return {

'regime': data['regime'], # 'bull', 'bear', or 'chop'

'confidence': data['confidence'], # 0.0 to 1.0

'signals': data['signals'], # individual signal breakdown

}

regime = get_regime()

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

TypeScript with the Regime SDK

npm install getregime

import { RegimeClient } from 'getregime';

const regime = new RegimeClient(); // Free tier, no API key needed

async function getRegimeAwareSignal(closes: number[]) {

const smaSignal = getSignal(closes);

const market = await regime.getRegime();

// Regime-aware position sizing

let sizeFactor = 1.0;

if (market.regime === 'chop') {

sizeFactor = 0.3; // Cut size 70% in choppy markets

} else if (market.regime === 'bear' && smaSignal === 'LONG') {

sizeFactor = 0.5; // Reduce longs in bear markets

} else if (market.confidence > 0.85) {

sizeFactor = 1.0; // Full size in high-confidence trends

}

return { signal: smaSignal, regime: market.regime, sizeFactor };

}

Combining Regime with Strategy Logic

The most effective pattern we've found is using regime as a sizing filter, not a trade blocker. Our backtests showed that completely blocking trades in unfavorable regimes hurts performance — you miss the early moves of regime transitions. Instead, scale down:

def regime_adjusted_size(base_size: float, regime: dict) -> float:

"""Adjust position size based on market regime."""

confidence = regime['confidence']

if regime['regime'] == 'chop':

return base_size * 0.3 # Choppy = small positions

if regime['regime'] == 'bull':

# Scale with confidence: 50% at low confidence, 100% at high

return base_size (0.5 + 0.5 confidence)

if regime['regime'] == 'bear':

# Bear regime: full size for shorts, reduced for longs

return base_size * confidence # Higher confidence = bigger short

return base_size

Step 6: Build the Execution Loop

Now let's wire everything together into a loop that runs on a schedule.

import time

import ccxt

def run_bot():

exchange = ccxt.binanceus({

'apiKey': 'YOUR_KEY',

'secret': 'YOUR_SECRET',

})

position = None # Track current position

while True:

try:

# 1. Fetch latest candles

ohlcv = exchange.fetch_ohlcv('BTC/USDT', '4h', limit=200)

df = pd.DataFrame(ohlcv, columns=['ts','open','high','low','close','volume'])

# 2. Generate signal

signals = sma_crossover_signals(df)

signal = signals.iloc[-1]['signal']

# 3. Check regime

regime = get_regime()

# 4. Calculate position size

base_size = 1000 # $1000 base

size = regime_adjusted_size(base_size, regime)

# 5. Execute if signal changed

if signal == 1 and position != 'LONG':

amount = size / df.iloc[-1]['close']

exchange.create_market_buy_order('BTC/USDT', amount)

position = 'LONG'

print(f"LONG BTC | size=${size:.0f} | regime={regime['regime']}")

elif signal == -1 and position != 'SHORT':

if position == 'LONG':

# Close long first

exchange.create_market_sell_order('BTC/USDT', amount)

position = 'SHORT'

print(f"SHORT BTC | size=${size:.0f} | regime={regime['regime']}")

# 6. Sleep until next candle

time.sleep(4 60 60) # 4 hours

except Exception as e:

print(f"Error: {e}")

time.sleep(60) # Retry after 1 min

if __name__ == '__main__':

run_bot()

Step 7: Go Live (Safely)

Before switching from paper to live trading:

Common Mistakes to Avoid

Over-fitting to historical data. If your strategy has 15 parameters, it's curve-fit to the past. SMA 50/200 has exactly 2 parameters and works across multiple assets and timeframes.

Ignoring fees. A strategy that makes 0.1% per trade sounds great until you realize you're paying 0.1% in taker fees. Use limit orders (maker fees) wherever possible.

No regime awareness. This is the single biggest differentiator between bots that survive and bots that blow up. A bot that trades the same way in a bull market and a bear market is a bot that loses money.

Trading too many pairs. Start with BTC. Add ETH once you're profitable. Add SOL once ETH is working. Complexity is the enemy of reliability.

What's Next

This guide gives you a working bot with regime-aware sizing. To take it further: