Crypto Correlation Trading

Crypto Correlation Trading: Finding Pairs That Move Together and Apart

Correlation trading exploits the relationship between assets. When correlated pairs diverge, one is mispriced—and that mispricing is your opportunity.

This guide covers how to find, measure, and trade crypto correlations.

Understanding Crypto Correlations

What Correlation Measures

Correlation coefficient (-1 to +1):

• +1: Perfect positive correlation (move together)
• 0: No correlation (independent movement)
• -1: Perfect negative correlation (move opposite)

Crypto Correlation Reality

Most cryptocurrencies are highly correlated:

• BTC/ETH: ~0.85
• BTC/major alts: 0.7-0.9
• Alt/Alt within sectors: 0.8-0.95

During market stress, correlations spike toward 1. Everything sells together.

Why Correlations Matter

1. Diversification illusion: High correlation means your "diversified" portfolio isn't
2. Relative value: Divergences from normal correlation = opportunities
3. Risk management: Correlated positions compound risk

Calculating Correlations

Rolling Correlation

import pandas as pd

def calculate_correlation(prices_a, prices_b, window=30):
    """Calculate rolling correlation between two assets"""
    returns_a = prices_a.pct_change()
    returns_b = prices_b.pct_change()
    
    correlation = returns_a.rolling(window).corr(returns_b)
    return correlation

Correlation Matrix

def correlation_matrix(price_df):
    """Calculate correlation matrix for multiple assets"""
    returns = price_df.pct_change()
    return returns.corr()

Interpreting Results

Pair Trading Strategy

The Concept

Find two correlated assets. When they diverge from their normal relationship, bet on convergence:

• Long the underperformer
• Short the outperformer
• Profit when they converge

Pair Selection Criteria

1. High historical correlation (> 0.7)
2. Fundamental relationship (same sector, use case)
3. Sufficient liquidity for both assets
4. Similar market cap tier (avoid pairing BTC with micro caps)

Good Crypto Pairs

Spread Calculation

def calculate_spread(prices_a, prices_b, method='ratio'):
    """
    Calculate spread between two assets
    """
    if method == 'ratio':
        spread = prices_a / prices_b
    elif method == 'difference':
        # Normalize first
        norm_a = prices_a / prices_a.iloc[0]
        norm_b = prices_b / prices_b.iloc[0]
        spread = norm_a - norm_b
    
    return spread

def zscore_spread(spread, window=20):
    """Calculate z-score of spread"""
    mean = spread.rolling(window).mean()
    std = spread.rolling(window).std()
    zscore = (spread - mean) / std
    return zscore

Entry and Exit Rules

Entry: - Z-score > 2: Short spread (short A, long B)

• Z-score < -2: Long spread (long A, short B)

Exit: - Z-score returns to 0: Close position

• Stop loss: Z-score > 3 (or <-3)

Example Trade

ETH/SOL spread Normal ratio: 0.05 (20 SOL per ETH) Current ratio: 0.045 (22 SOL per ETH) Z-score: -2.3 (ETH underperforming)

Position: - Long 1 ETH

• Short 22 SOL

• Expected outcome: Ratio returns to 0.05 → ETH appreciates relative to SOL

Correlation Breakdown Trading

The Opportunity

When correlations break, something fundamental has changed—or there's a temporary dislocation.

Identifying Breakdowns

def detect_correlation_breakdown(correlation, threshold=0.5, lookback=60):
    """
    Detect when correlation drops significantly
    """
    avg_correlation = correlation.rolling(lookback).mean()
    
    breakdown = correlation < (avg_correlation - threshold)
    return breakdown

Trading the Breakdown

Scenario 1: Temporary dislocation

• One asset hit by news, other unaffected
• Correlation will likely restore
• Trade: Mean reversion (pair trade)

Scenario 2: Fundamental change

• Real difference in fundamentals emerged
• Correlation may stay low
• Trade: Follow the divergence

Distinguishing Scenarios

Ask:

1. Is there news explaining the divergence?
2. Has something fundamental changed?
3. How long has the breakdown persisted?
4. Are other related pairs showing similar patterns?

Sector Correlation Analysis

Tracking Sector Relationships

Group assets by sector and track correlation changes:

sectors = {
    'L1': ['ETH', 'SOL', 'AVAX', 'ADA'],
    'DeFi': ['UNI', 'AAVE', 'CRV', 'MKR'],
    'Gaming': ['AXS', 'SAND', 'MANA', 'GALA'],
    'Infrastructure': ['LINK', 'GRT', 'FIL', 'AR']
}

def sector_correlation(price_df, sectors):
    """Calculate intra-sector correlations"""
    results = {}
    for sector, tokens in sectors.items():
        sector_prices = price_df[tokens]
        sector_corr = sector_prices.pct_change().corr()
        results[sector] = sector_corr.mean().mean()
    return results

Sector Rotation Signals

• Rising sector correlation: Sector moving as unit (macro driven)
• Falling sector correlation: Dispersion (alpha opportunity within sector)

When intra-sector correlation drops, individual token selection matters more.

Risk Management for Correlation Trades

Position Sizing

def pair_position_size(account, risk_per_trade, spread_volatility):
    """
    Size pair trade positions
    """
    # Risk amount
    risk_amount = account * risk_per_trade
    
    # Spread standard deviation (recent)
    spread_std = spread_volatility
    
    # Position size (each leg)
    position_size = risk_amount / (2 * spread_std)
    
    return position_size

Stop Losses

Fixed spread stop: - Enter at z-score 2

• Stop at z-score 3
• Risk = 1 spread standard deviation

Time stop: - Maximum holding period: 10-20 days

• Exit if no convergence

Correlation Risk

Correlations aren't stable. A 0.85 correlation can drop to 0.5 during stress:

• Monitor correlation changes during trade
• Exit if correlation breaks significantly
• Don't assume historical correlation holds

Tools for Correlation Analysis

Data Sources

• TradingView: Built-in correlation indicator
• CoinMetrics: Professional correlation data
• Messari: Sector analysis
• Custom: Build with Python + price data

Visualization

import seaborn as sns
import matplotlib.pyplot as plt

def plot_correlation_heatmap(correlation_matrix):
    """Plot correlation matrix as heatmap"""
    plt.figure(figsize=(12, 10))
    sns.heatmap(correlation_matrix, 
                annot=True, 
                cmap='RdYlGn',
                center=0,
                vmin=-1, 
                vmax=1)
    plt.title('Crypto Correlation Matrix')
    plt.show()

Real-Time Monitoring

Set alerts for:

• Z-score threshold breaches
• Correlation breakdown events
• Spread hitting extremes

Advanced Strategies

Cointegration vs Correlation

Correlation measures linear relationship. Cointegration measures long-term equilibrium.

Two assets can be cointegrated but have low short-term correlation. Cointegration is more robust for pair trading.

from statsmodels.tsa.stattools import coint

def test_cointegration(prices_a, prices_b):
    """Test if two price series are cointegrated"""
    score, pvalue, _ = coint(prices_a, prices_b)
    return {
        'cointegrated': pvalue < 0.05,
        'pvalue': pvalue,
        'score': score
    }

Multi-Leg Spreads

Trade baskets instead of pairs:

• Long: 50% ETH + 50% SOL
• Short: 100% BTC
• Bet on alt outperformance vs BTC

Dynamic Hedging

Adjust hedge ratio based on changing correlation:

def optimal_hedge_ratio(returns_a, returns_b, window=30):
    """Calculate rolling optimal hedge ratio"""
    covariance = returns_a.rolling(window).cov(returns_b)
    variance_b = returns_b.rolling(window).var()
    hedge_ratio = covariance / variance_b
    return hedge_ratio

Common Mistakes

1. Assuming Stable Correlations

Correlations change, especially during stress. Don't treat historical correlation as guaranteed.

2. Ignoring Transaction Costs

Pair trades require multiple executions. Fees compound on both legs.

3. Over-Leveraging

Pair trades seem safe but can diverge further than expected. Size conservatively.

4. Fighting Trends

Don't pair trade against strong trends. Underperformance can persist longer than you expect.

5. Too Many Pairs

Focus on 2-3 well-understood pairs rather than trading every divergence.

FAQs

What's the minimum capital for pair trading? $5,000+ recommended to make fee impact manageable. $10,000+ for multiple pairs.

How long do pair trades typically last? Days to weeks. Quick convergence (hours) is rare. Extended divergence (months) suggests fundamental change.

Should I trade highly correlated or moderately correlated pairs? High correlation (0.8+) for mean reversion. Moderate (0.5-0.7) for breakdown/regime change trades.

Can I pair trade with leverage? Yes, but reduce leverage since you have exposure on both legs. 2-3x maximum for pair trades.