Independent return streams for your book

BTC Alpha is backtested performance data for 14 systematic BTC strategies, delivered as a clean REST/JSON API so you can measure them against your own portfolio. Factual, modelled historical data — not advice, not a recommendation, not a forecast.

Try it in 60 seconds — no key

Every historical endpoint is open — free, no key. Here's the catalogue:

curl https://btc-strategy-data-api.fly.dev/v1/strategies

{
  "data": [
    {
      "id": "helios",
      "name": "Helios",
      "tv_status": "provisional",
      "verification_state": "dual_verified",
      "headline": {
        "cagr_pct": 50.51,
        "max_drawdown_pct": -33.32,
        "sharpe_daily_annualized": 1.18,
        "profit_factor": 2.60,
        "trade_count": 240
      }
    }
  ],
  "meta": { "basis": "backtested", "count": 14 },
  "links": { "self": "/v1/strategies", "summary": "/v1/summary" }
}

Real backtested track records, instantly — free, no key. Each strategy carries two confidence signals: verification_state (internal validation depth — dual_verified here) and tv_status (external TradingView cross-check — provisional until reconciled), explained here.

Why a quant cares

These aren't tips — they're return series. Most crypto books are long-BTC-beta; these strategies move largely independently of each other (mean pairwise correlation ≈ 0.35 → about 2.5 independent bets across the 14 — and the least-correlated pair, helios / kronos, is actually negative at −0.09). The question that actually matters isn't "what's the CAGR" — it's:

Does adding one of these to my book improve its risk-adjusted return?

Here's that question, answered as 20 lines of Python.

The recipe: does this improve my book?

# Pull a strategy's daily returns, correlate with YOUR book, and see what blending
# it in does to your Sharpe.   pip install requests numpy
import csv, requests, numpy as np

API, STRAT = "https://btc-strategy-data-api.fly.dev", "helios"   # free — no key

r = requests.get(f"{API}/v1/strategies/{STRAT}/returns",
                 params={"period": "daily"})
r.raise_for_status()
strat = {p["t"]: p["ret"] for p in r.json()["data"]}

# YOUR book's daily returns, same ISO dates (CSV columns: date,return)
mine = {row["date"]: float(row["return"]) for row in csv.DictReader(open("my_returns.csv"))}

dates = sorted(set(strat) & set(mine))
s = np.array([strat[d] for d in dates]); b = np.array([mine[d] for d in dates])
sharpe = lambda x: x.mean() / x.std(ddof=1) * np.sqrt(365)

print(f"correlation to your book : {np.corrcoef(s, b)[0,1]:+.2f}")
print(f"your book Sharpe         : {sharpe(b):.2f}")
for w in (0.10, 0.20, 0.30):
    print(f"  + {w:.0%} {STRAT:<7} -> Sharpe {sharpe((1-w)*b + w*s):.2f}")

What it looks like — an illustrative run where "your book" is a sample diversified book (an equal-weight blend of the other strategies). Your numbers will differ — plug in your own returns:

correlation to your book : +0.16     (near 0 = an almost independent return stream)
your book Sharpe         : 1.46
  + 10% helios -> Sharpe 1.67
  + 20% helios -> Sharpe 1.74
  + 30% helios -> Sharpe 1.69

:::warning Illustrative example — not a promise of your result The "book" above is a sample (an equal-weight blend of the other strategies), shown so you can see the shape of the answer. It is not a forecast of your portfolio's outcome. Swap in your returns and read your number. All figures are backtested / modelled historical data, provisional pending independent (TradingView) verification — not advice, not a recommendation. :::

The takeaway you'd reason about: a near-zero correlation means the strategy is a largely independent return stream, so a modest sleeve can lift a book's risk-adjusted return through diversification — if it holds for your book. That's the point: run it on your data.

→ Full runnable recipe — the full series (free, no key), the CSV loader, and how to size the sleeve.

All historical data is free

Every endpoint is open — verify everything against your own model before you commit. The live signals are the paid product (separate keyed API).

Endpoint	Access
`GET /v1/strategies` · `/v1/strategies/{id}` (catalogue, metadata)	✅ free
`GET /v1/correlation` (cross-strategy matrix)	✅ free
`GET /v1/summary` (incl. equal-weight book)	✅ free
`GET /v1/strategies/{id}/stats · /returns · /curve`	✅ free
`GET /v1/export` (aligned returns matrix)	✅ free

Try any of them right now, no key:

curl "https://btc-strategy-data-api.fly.dev/v1/correlation?period=daily"
curl "https://btc-strategy-data-api.fly.dev/v1/summary"

The historical data above is free — verify everything first. When you want to act on these strategies in real time, the product is the live signals: actionable trade signals as each strategy fires (is_test: false), via a separate keyed API.

Evaluate free — run the recipe against your own book.
Subscribe — live signals are request-based today: contact for access.
Send your signals key as the X-API-Key header — see Access & Authentication.

The recipe

Evaluate a strategy (or a bundle) against your portfolio — runnable Python.

Access & Authentication

Free historical data vs the keyed live-signals API.

API Reference

Every endpoint with schemas, examples and a live playground.

Methodology

Exactly how every number is produced — checked against the data.