Carry Factor Analysis
Analyze the carry risk factor in cryptocurrency markets captured primarily through perpetual futures funding rate spreads and futures term structure premiums, measuring its risk-adjusted return characteristics, cyclicality, and correlation to other systematic risk factors across market regimes.
Carry Factor Analysis — Research & Experimentation
Category: Research & Experimentation | Subcategory: Factor Research
What This Notebook Does
Carry is the return you earn from holding an asset when its price stays unchanged. In traditional FX markets, carry is the interest rate differential between two currencies — you earn carry by borrowing a low-rate currency and investing in a high-rate one. In crypto markets, carry takes two forms:
-
Funding rate carry: crypto perpetual futures pay/receive a funding rate every 8 hours. When most traders are long (bullish), the funding rate is positive — longs pay shorts. A funding rate carry strategy goes long assets with negative funding (being paid to hold) and short assets with high positive funding.
-
Basis carry: the difference between the spot price and the futures price (basis). Positive basis = futures > spot (contango) — you earn carry by selling futures and buying spot.
This notebook models funding rate carry because it's the most common form in crypto and directly available from on-chain data or exchanges. Since we can't fetch live funding rate data without an API key, synthetic funding rates are generated that match realistic statistical properties (positively autocorrelated, positive on average in bull regimes).
This notebook:
- Simulates funding rates for multiple assets
- Constructs a long-short carry factor
- Analyses carry against market regimes (bull vs bear)
- Tests carry factor persistence and IC
- Compares carry with momentum factor
- Exports factor data
!pip install numpy pandas matplotlib seaborn scipy yfinance --quietimport numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from scipy import stats
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
plt.rcParams['figure.figsize'] = (14, 5)
plt.rcParams['axes.spines.top'] = False
plt.rcParams['axes.spines.right'] = False
print('Imports ready.')Imports ready.
Section 1 — Configuration
FUNDING_FREQ is how often we assume the funding rate is recorded (daily annualised equivalent). REBAL_FREQ determines how often the carry portfolio is rebalanced based on updated funding rates — carry is typically slow-moving so weekly rebalancing is sufficient.
# ── Data Source Toggle ─────────────────────────────
# Note: live funding rates require an exchange API; USE_LIVE_DATA fetches spot prices only.
# Synthetic funding rates are always generated to construct the carry factor.
USE_LIVE_DATA = False
TICKERS = ['BTC-USD','ETH-USD','SOL-USD','BNB-USD','AVAX-USD']
START_DATE = '2020-01-01'
END_DATE = '2024-12-31'
# ──────────────────────────────────────────────────
ASSETS = ['BTC','ETH','SOL','BNB','AVAX']
TOP_N = 2 # long bottom-N funding (paid to hold), short top-N
REBAL_FREQ = 5 # rebalance weekly
LOOKBACK_MOM = 21 # 1-month momentum for comparison
print('Config ready.')Config ready.
Section 2 — Data Acquisition & Synthetic Funding Rates
We generate synthetic funding rates as AR(1) processes with a positive mean (matching crypto perpetuals where funding averages ~0.01%/8h). The funding rate for each asset has a shared market component (when BTC funding is high, most assets trend positive) and an idiosyncratic component that creates cross-sectional dispersion for the carry factor to exploit.
rng = np.random.default_rng(42)
if USE_LIVE_DATA:
import yfinance as yf
prices = yf.download(TICKERS, start=START_DATE, end=END_DATE)['Close']
prices.columns = ASSETS
prices.dropna(inplace=True)
returns = prices.pct_change().dropna()
print(f'Live spot prices: {len(returns)} days')
else:
n = 1200
vols = np.array([0.65,0.75,1.20,0.70,1.10]) / np.sqrt(252)
mu = np.array([0.30,0.25,0.55,0.20,0.50]) / 252
corr = np.full((5,5), 0.65); np.fill_diagonal(corr, 1.0)
cov = np.outer(vols, vols) * corr
L = np.linalg.cholesky(cov)
data = rng.standard_t(df=4, size=(n, 5)) @ L.T + mu
idx = pd.date_range('2020-01-01', periods=n, freq='B')
returns = pd.DataFrame(data, columns=ASSETS, index=idx)
prices = (1 + returns).cumprod() * 100
print(f'Synthetic spot data: {n} days')
# Generate synthetic funding rates (always synthetic, exchange API needed for live)
n = len(returns)
# Shared market sentiment drives funding rates
market_sentiment = np.zeros(n)
for t in range(1, n):
market_sentiment[t] = 0.85 * market_sentiment[t-1] + rng.standard_normal() * 0.02
# Per-asset idiosyncratic funding
funding_rates = pd.DataFrame(index=returns.index, columns=ASSETS, dtype=float)
base_funding = np.array([0.015, 0.020, 0.025, 0.018, 0.022]) # annualised %, differ per asset
for i, asset in enumerate(ASSETS):
idio = np.zeros(n)
for t in range(1, n):
idio[t] = 0.70 * idio[t-1] + rng.standard_normal() * 0.01
funding_rates[asset] = base_funding[i] + 0.5 * market_sentiment + idio
print(f'Synthetic funding rates generated: mean {funding_rates.mean().mean():.3f} ann. %/day')Synthetic spot data: 1200 days Synthetic funding rates generated: mean 0.023 ann. %/day
Section 3 — Carry Factor Portfolio
The carry factor goes long the TOP_N assets with the lowest funding rate (they are being paid to hold these assets, or paying the least) and short the TOP_N assets with the highest funding rate. This is the rational arbitrage: earn the funding rate spread between the two legs plus any spot price return differential.
carry_rets = pd.Series(np.nan, index=returns.index)
long_w = np.zeros(len(ASSETS))
short_w = np.zeros(len(ASSETS))
for t in range(1, len(returns)):
if t % REBAL_FREQ == 0:
# Rank by funding rate (low = carry long, high = carry short)
today_funding = funding_rates.iloc[t]
ranks = today_funding.rank()
long_mask = ranks <= TOP_N
short_mask = ranks >= (len(ranks) - TOP_N + 1)
long_w = long_mask.astype(float).values / TOP_N
short_w = short_mask.astype(float).values / TOP_N
daily = returns.iloc[t].values
# Carry return = spot return + funding earned
funding_today = funding_rates.iloc[t].values / 252
carry_rets.iloc[t] = ((long_w * (daily + funding_today)).sum()
- (short_w * (daily - funding_today)).sum())
carry_rets = carry_rets.dropna()
sharpe = carry_rets.mean() / (carry_rets.std() + 1e-9) * np.sqrt(252)
print(f'Carry factor: Ann Ret={carry_rets.mean()*252:.1%}, Sharpe={sharpe:.2f}')Carry factor: Ann Ret=20.9%, Sharpe=0.27
Section 4 — Regime Analysis
Carry strategies tend to perform well in stable, trending markets (positive carry earned + no crashes) but suffer in volatile, risk-off regimes when all assets fall. We classify market regimes as bull/bear using the 60-day rolling BTC return and measure carry performance separately in each regime.
btc_roll = returns['BTC'].rolling(60).mean()
aligned = btc_roll.reindex(carry_rets.index).dropna()
carry_al = carry_rets.reindex(aligned.index)
bull_mask = aligned > 0
bear_mask = ~bull_mask
def sharpe_ratio(r):
return r.mean() / (r.std() + 1e-9) * np.sqrt(252)
print('=== Carry Factor Performance by Regime ===')
print(f'Bull regime ({bull_mask.sum()} days): Sharpe = {sharpe_ratio(carry_al[bull_mask]):.2f}, Ann Ret = {carry_al[bull_mask].mean()*252:.1%}')
print(f'Bear regime ({bear_mask.sum()} days): Sharpe = {sharpe_ratio(carry_al[bear_mask]):.2f}, Ann Ret = {carry_al[bear_mask].mean()*252:.1%}')=== Carry Factor Performance by Regime === Bull regime (622 days): Sharpe = 0.04, Ann Ret = 3.2% Bear regime (519 days): Sharpe = 0.67, Ann Ret = 53.4%
This function calculates the Sharpe ratio, a measure of risk-adjusted return. It's defined as the average return divided by the standard deviation of returns, annualized by multiplying by the square root of 252 (number of trading days in a year).
Section 5 — Visualisation
The left panel shows the carry factor equity curve with bull/bear regime shading. The right panel shows the distribution of carry factor daily returns split by regime — this makes it visually clear whether the factor behaves differently during market stress.
fig, axes = plt.subplots(1, 2, figsize=(14, 5))
fig.suptitle('Carry Factor Analysis', fontsize=13, fontweight='bold')
ax1 = axes[0]
eq = (1 + carry_al).cumprod()
ax1.plot(eq.index, eq, color='#1976d2', lw=1.5, label='Carry Factor')
ax1.fill_between(aligned.index,
eq.reindex(aligned.index).min() * 0.9,
eq.reindex(aligned.index).max() * 1.05,
where=bull_mask, alpha=0.06, color='green', label='Bull regime')
ax1.fill_between(aligned.index,
eq.reindex(aligned.index).min() * 0.9,
eq.reindex(aligned.index).max() * 1.05,
where=bear_mask, alpha=0.06, color='red', label='Bear regime')
ax1.set_ylabel('Cumulative Return'); ax1.legend(fontsize=8)
ax1.set_title('Carry Factor Equity Curve with Regimes')
ax2 = axes[1]
ax2.hist(carry_al[bull_mask], bins=40, alpha=0.6, color='green', density=True, label='Bull')
ax2.hist(carry_al[bear_mask], bins=40, alpha=0.6, color='red', density=True, label='Bear')
ax2.axvline(0, color='black', lw=0.8, ls='--')
ax2.set_xlabel('Daily Return'); ax2.legend(fontsize=9)
ax2.set_title('Return Distribution by Regime')
plt.tight_layout(); plt.show()
Section 6 — Export
Save carry factor returns alongside the funding rate data and regime classification for downstream factor combination and portfolio construction analysis.
out = pd.DataFrame({
'carry_factor': carry_al,
'bull_regime': bull_mask.astype(int).reindex(carry_al.index)
})
out.to_csv('carry_factor_analysis.csv')
funding_rates.to_csv('carry_factor_funding_rates.csv')
print('Saved: carry_factor_analysis.csv, carry_factor_funding_rates.csv')Saved: carry_factor_analysis.csv, carry_factor_funding_rates.csv
Conclusion
This notebook successfully simulated funding rates and constructed a long-short carry factor. The analysis showed that the carry factor's performance varies significantly with market regimes, highlighting the importance of regime-aware strategies. The factor returns and funding rate data were exported for further analysis and potential integration into portfolio construction.