BTC and ETH funding-rate carry bot · delta-neutral

CARRY

A market-neutral position on BTC and ETH whose return is the perpetual funding rate rather than a price move. Nothing is forecast, nothing is timed, and there is no signal. The figures below come from 2,190 settlements per symbol, and the few that rest on a longer price history say so.

Buy CARRY · $199 ↗ Compare with APEX

CARRY

BTC and ETH perpetuals · delta-neutral · a funding yield

2,190 settlements per symbol · Jun 2024 – Jun 2026

What it is, in the sentence that matters

A market-neutral position on BTC and ETH whose return is the perpetual funding rate rather than a price move. Nothing is forecast, nothing is timed, and there is no signal. The research below prices exactly what it costs to hold.

+4.88% / +4.91%Net APR unlevered, BTC / ETH, after both legs' fees and slippage

+12.5%Net APR on total equity at 3.4x reference leverage, with a 25% tail reserve

3.4xReference leverage at the documented rebalance cadence. ETH binds the book

2,190Funding settlements per symbol, every one of them joined

34 bpsCost of one round trip at the modelled fees (about 35 on Bybit): about 25 days of funding to earn back

14.9Break-even round trips a year, the same at every leverage

18.9%Of BTC settlements paid negative funding. You pay, on those

0 of 389Negative-funding stretches worth dodging, with perfect foresight

The number that decides this: funding by calendar year, unlevered, before basis and costs

BTC

funding, %/yr

2024: +8.18%
2025: +5.13%
2026 to Jun: +1.00%

ETH

funding, %/yr

2024: +9.40%
2025: +4.93%
2026 to Jun: +0.35%

Funding is regime-dependent, and every year measured is in the table above. The headline is a two-year mean rather than a forecast. The package reads no cached rate: you take the current number off your own venue's funding page, so the decision to deploy is always made on today's figure.

The risk profile, in full

10xLeverage at which liquidation inside a year is near-certain at that cadence

~7xWhere surviving a year becomes roughly a coin-flip (23% if either leg counts), over 5.5 years of prices. At 5x, about a 70% chance of surviving a year (58% if a liquidation on either leg counts)

RequiredUnified margin. Split accounts let a rally liquidate the short while the spot gain sits where it cannot rescue it

Two legsSpot and perp, on one venue, with transfer and custody risk on both

Holding is how the yield is earned: break-even is 14.9 round trips a year at every leverage, and across the 389 negative-funding stretches in the sample, perfect foresight could not justify stepping aside from a single one. Leverage multiplies carry and trading cost by the same number, so it moves no break-even; size it for capital you can leave in place.

The sample

Two years of settlements, every one of them joined.

The figures in this section are regenerated from the raw settlement data that ships with the package, by the command at the end of it.

2,190Funding settlements per symbol, BTC and ETH alike

730 dSample span, 2024-06-14 to 2026-06-13

+0.460BTC mean funding, bp per settlement

+0.468ETH mean funding, bp per settlement

+0.01% / −0.05%Basis contribution, BTC / ETH. The return is funding, not basis

+4.89%Held net APR, BTC and ETH blended, unlevered

An exact-timestamp join keeps only 60.6% of the settlements. The 39.4% it drops are not random: the dropout correlates −0.60 with funding on BTC and −0.67 on ETH, so the rows that survived were the richer ones and every figure computed from them read high. On BTC the funding the old join kept averaged +0.521 bp against +0.366 bp for what it discarded (ETH: +0.528 against +0.377).

The snapped join used here drops none of the 2,190, and the headline figures are what came out after that was fixed. You can re-run it: python3 -m carry.cli verify regenerates every figure it checks from the shipped data and prints any that disagree; the package's disclosure document lists the few it does not check, and why.

Terminal · from the unpacked download

$ cd carry-1.0.0/engine
$ pip install numpy pandas
$ python3 -m carry.cli verify  # about a second, no network

The evidence

(click any chart to open it full size)

Each one is drawn from the same 2,190 settlements per symbol that verify regenerates its figures from.

01/04

Held, against the same position traded

Cumulative net yield, BTC+ETH blended, 2024 – 2026

The whole argument in one image. Holding earns +9.8% over the two years after its one round trip; the identical position traded 14 times a year earns +0.6%, and at 52 round trips it loses 25.2%. Each round trip costs 34 bps of notional and produces nothing.

02/04

The break-even surface

Round trips per year × leverage → net APR

Three-dimensional surface
of net APR against round trips per year and leverage, with the break-even ridge
marked at 14.9 round trips a year

Leverage tilts the whole surface without moving where it crosses zero: carry and cost are both percentages of the same notional, so the break-even ridge is a straight line at 14.9 round trips a year at every leverage.

03/04

The join audit

Why 39.4% of the settlements could not simply be dropped

One point per calendar quarter: how many settlements the old exact-timestamp join discarded, against the mean funding in that quarter. The line slopes down (corr −0.60 on BTC and −0.67 on ETH), so the quarters it dropped most were the ones paying most. On BTC what survived averaged +0.521 bp against +0.366 bp for what it discarded (ETH: +0.528 against +0.377), and every figure computed from the survivors read high. The snapped join used here drops none of the 2,190.

04/04

Funding by year

Mean funding, annualised, unlevered

Every calendar year in the sample, both symbols. The headline +4.88% / +4.91% is the two-year mean; these are the years it is made of, so you can see the shape of it rather than take the average on trust.

The cost of holding it

Priced to the basis point, before you deploy anything.

Carry and cost are both percentages of the same notional, so leverage moves them together and the break-even trip count does not shift.

34 bpsFull round trip, both legs, fees and slippage included, at the modelled OKX VIP0 fees. On Bybit's non-VIP fees it is about 35 bps

25 / 24 dFunding needed to earn one round trip back, BTC / ETH

14.9Round trips a year that consume the whole yield, identical at every leverage

A position held is a position earning, and every round trip is 25 days of yield spent. The shipped tools count what has been spent against what the position earns in a year, so it is a number you read rather than one you estimate.

The question everyone asks first

Holding through the quiet stretches is what earns the yield.

Tested with perfect foresight, knowing every negative stretch before it began: stepping aside costs more than it saves, so the bot simply holds.

185 / 204Negative-funding stretches in the sample, BTC / ETH

0 of 185BTC stretches worth dodging, knowing them in advance

0 of 204ETH stretches worth dodging

9.1 bpLargest single negative stretch on BTC, against a 34 bp round trip to step out and back in

−30.8% / −33.9%Change in annual return against holding, from dodging every negative stretch, BTC / ETH

18.9%Of BTC settlements that pay negative, already inside the +4.88%

The dodge turned a positive yield deeply negative, because stepping aside and back costs 3.7 times the largest stretch it avoids. This is the finding that decides how the method is operated, and it is regenerated from the same data as everything else here.

Buying

What you actually receive.

The download

Every folder, before you pay.

A map of the release archive, names only. The files themselves arrive on purchase. The tree is generated from the CARRY 1.0.0 download itself, so it cannot drift from what you receive. Open any folder.

carry-1.0.0

engine

carry

docs

CARRY_manual.pdf

CARRY_manual.sources.sha256

DISCLOSURE.md

LEVERAGE.md

README.md

RISK.md

SETUP.md

TROUBLESHOOTING.md

WALKTHROUGH.md

execution

__init__.py

bybit.py

engine.py

evidence.py

ledger.py

mock.py

runner.py

state.py

venue.py

tests

_support.py

test_cli.py

test_docs_parity.py

test_execution_bybit.py

test_execution_engine.py

test_execution_ledger.py

test_execution_runner.py

test_fetch_data.py

test_manual_build.py

test_research_invariants.py

test_verify.py

tools

build_manual.py

fetch_data.py

probe_capabilities.py

__init__.py

__main__.py

cli.py

sources.py

verify.py

research

01-carry-delta-neutral

analysis

CHURN_FRONTIER.md

churn_frontier.py

fetch_klines_binance.py

frontier.py

frontier1h.py

README.md

data

binance_BTCUSDT_8h.csv

binance_ETHUSDT_8h.csv

binance_spot_BTCUSDT_8h.csv

binance_spot_ETHUSDT_8h.csv

funding_BTCUSDT.csv

funding_ETHUSDT.csv

funding_SOLUSDT.csv

experiments

carry_pnl_projection.py

funding_carry_experiment_001.py

funding_carry_experiment_002.py

funding_carry_experiment_003_costs.py

funding_carry_experiment_004_paper.py

research

RESEARCH_funding_carry.md

RISK_carry.md

src

carry_harvester.py

fetch_funding.py

fetch_klines.py

live_funding.py

metrics.py

risk_engine.py

venue_params.py

tests

test_funding_join.py

test_net_carry_constant.py

README.md

LICENCE.txt

QUICKSTART.md

README.md

SHA256SUMS

Get started

Read the disclosures. Then decide.

Everything that bears on the decision is published here and in the pre-sale agreement: the yield, the leverage and the terms. Read it once, then choose the setting that suits you.

Every performance figure for these products comes from a backtest, a simulation over historical data, and trading leveraged cryptocurrency derivatives can lose you more than your deposit. APEX has a maximum historical drawdown of −71.6% at its highest setting and −42.0% at the conservative setting that ships (−71.9% and −44.6% with no limit on open positions). CARRY’s figures come from two years of settlements, and the funding regime that produces its yield is decaying.

Nothing here is investment advice. You run the software on your own exchange account and keep custody of your funds. The complete risk statement is in the pre-sale agreement, which you accept before any payment.

Sales are final, with two exceptions set out in the pre-sale agreement: a published figure that the product's verify command checks and that doesn't reproduce is refunded in full, and a defect no update can fix may be refunded at the seller's discretion. Otherwise the source code and the research record are delivered on purchase and can't be returned, which is exactly why every number that bears on the decision is above, before you pay, rather than in terms you'd have to go looking for.

Buy APEX · $399 Buy CARRY · $199 Buy both · $499 Why APEX access is limited

One-time, in crypto. Both are on sale now, and the bundle is $99 below buying them apart. Nothing here is a subscription and there is no performance fee on either.

Runs on Bybit, with a dedicated adapter. The bot verifies your account can do what the method needs before it arms, so it only ever trades where it has been verified.