LEAPS vs Margin Loan: The Financing Cost

LEAPS vs a margin loan comes down to one number: the interest rate you pay to hold shares you have not fully paid for. A margin loan prints that rate on your statement. A deep in the money LEAPS hides it inside the premium, where it can still be recovered exactly, from the price of one call and one put at the same strike. Below is that arithmetic on a real AAPL pair, line by line, off the latest session in the options history, with that session date printed in the panel.

What you are borrowing when you buy a deep ITM LEAPS

A LEAPS (Long Term Equity AnticiPation Securities) is an ordinary listed option with a long life, usually more than a year to expiry; the mechanics are in what LEAPS are. "Deep in the money" means the call's strike sits far below the share price, so the contract is mostly intrinsic value and moves close to dollar for dollar with the stock. That is the appeal covered in deep ITM LEAPS: near share-like exposure for a fraction of the cash.

The rest of the cash has to come from somewhere. Whoever sold the call carries the hedge until expiry and charges for that carry inside the premium. Put call parity is the identity that makes the charge visible. For a call and a put on the same underlying, same strike, same expiry: call price minus put price equals share price minus the present value of the strike. Rearranged, the present value of the strike is share price minus call plus put. You know the strike and you know the term. The gap between the strike and its present value is interest.

Reading the implied financing rate off one real pair

The panel below takes the latest session in the options history, picks the AAPL third-Friday expiry nearest fifteen months out, and lines the call up against the put at each strike, from deep in the money out toward the share price. That expiry is the Dec 2027 contract, 450 calendar days past the close it is priced on.

SELECT
    concat('$', toString(toUInt32(strike_price)))                          AS strike,
    round(avg(toFloat64(underlying_close)), 2)                             AS stock_price,
    round(avgIf(toFloat64(option_close), leg = 'call'), 2)                 AS call_price,
    round(avgIf(toFloat64(option_close), leg = 'put'), 2)                  AS put_price,
    round(avgIf(toFloat64(option_close), leg = 'call')
        - avgIf(toFloat64(option_close), leg = 'put'), 2)                  AS net_debit,
    round(avg(toFloat64(underlying_close))
        - avgIf(toFloat64(option_close), leg = 'call')
        + avgIf(toFloat64(option_close), leg = 'put'), 2)                  AS amount_financed,
    concat(toString(max(days_to_expiry)), ' calendar days')                AS term_label,
    formatDateTime(max(expiration_date), '%b %Y')                          AS expiry_label,
    formatDateTime(max(date), '%b %e, %Y')                                 AS priced_on
FROM
(
    SELECT
        strike_price,
        underlying_close,
        option_close,
        days_to_expiry,
        expiration_date,
        date,
        if(lower(toString(option_type)) LIKE 'c%', 'call', 'put') AS leg
    FROM global_markets.options_greeks
    WHERE underlying_symbol = 'AAPL'
      AND date = (
            SELECT max(date)
            FROM global_markets.options_greeks
            WHERE underlying_symbol = 'AAPL'
      )
      AND expiration_date = (
            SELECT expiration_date
            FROM global_markets.options_greeks
            WHERE underlying_symbol = 'AAPL'
              AND date = (
                    SELECT max(date)
                    FROM global_markets.options_greeks
                    WHERE underlying_symbol = 'AAPL'
              )
              AND days_to_expiry >= 200
              AND toDayOfWeek(expiration_date) = 5
            GROUP BY expiration_date
            ORDER BY abs(toInt32(max(days_to_expiry)) - 450) ASC
            LIMIT 1
      )
      AND toFloat64(option_close) > 0
      AND toFloat64(strike_price) / toFloat64(underlying_close) BETWEEN 0.50 AND 0.95
      AND modulo(toUInt32(strike_price), 10) = 0
)
GROUP BY strike_price
HAVING countIf(leg = 'call') > 0
   AND countIf(leg = 'put') > 0
ORDER BY strike_price
LIMIT 12

Take the $250 strike, the deepest one where both legs printed a close that day. AAPL closed at $336.86 on Sep 23, 2026.

1. Buy the $250 call and pay $107.5.
2. Sell the $250 put and collect $7.51.
3. Net cash leaving the account today: $99.99.
4. That pair is a synthetic long. Above the strike the call finishes in the money, below it the put is assigned, and either way the position ends up long shares at $250. Its profit and loss tracks the stock dollar for dollar.
5. Buying the shares outright costs $336.86. Putting up $99.99 instead leaves $236.87 of the purchase price unfunded.
6. That balance is settled 450 calendar days later, by paying the $250 strike.

Borrow $236.87 today, repay $250 at expiry: a loan with the rate left as the only unknown. Divide the strike by the amount financed, take the natural log, divide by the term in years, and the rate falls out.

WITH
    (
        SELECT round(toFloat64(yield_1_year), 2)
        FROM global_markets.treasury_yields
        WHERE date <= (
                SELECT max(date)
                FROM global_markets.options_greeks
                WHERE underlying_symbol = 'AAPL'
        )
        ORDER BY date DESC
        LIMIT 1
    ) AS treasury_1y,
    (
        SELECT round(sum(paid), 4)
        FROM
        (
            SELECT max(toFloat64(cash_amount)) AS paid
            FROM global_markets.stocks_dividends
            WHERE ticker = 'AAPL'
              AND ex_dividend_date <= (
                    SELECT max(date)
                    FROM global_markets.options_greeks
                    WHERE underlying_symbol = 'AAPL'
              )
              AND ex_dividend_date > subtractDays(
                  (
                    SELECT max(date)
                    FROM global_markets.options_greeks
                    WHERE underlying_symbol = 'AAPL'
                  ), 365)
            GROUP BY ex_dividend_date
        )
    ) AS trailing_dividends
SELECT
    strike,
    round(100 * log(strike_k / financed) / term_years, 2)                          AS parity_rate_pct,
    round(100 * log(strike_k / (financed - trailing_dividends)) / term_years, 2)   AS dividend_adjusted_pct,
    treasury_1y                                                                    AS treasury_1y_pct,
    round(10000 * (log(strike_k / (financed - trailing_dividends))
                 - log(strike_k / financed)) / term_years, 0)                      AS dividend_adjustment_bps
FROM
(
    SELECT
        concat('$', toString(toUInt32(strike_price)))                 AS strike,
        toUInt32(strike_price)                                        AS strike_sort,
        toFloat64(strike_price)                                       AS strike_k,
        avg(toFloat64(underlying_close))
          - avgIf(toFloat64(option_close), leg = 'call')
          + avgIf(toFloat64(option_close), leg = 'put')               AS financed,
        max(days_to_expiry) / 365.0                                   AS term_years
    FROM
    (
        SELECT
            strike_price,
            underlying_close,
            option_close,
            days_to_expiry,
            if(lower(toString(option_type)) LIKE 'c%', 'call', 'put') AS leg
        FROM global_markets.options_greeks
        WHERE underlying_symbol = 'AAPL'
          AND date = (
                SELECT max(date)
                FROM global_markets.options_greeks
                WHERE underlying_symbol = 'AAPL'
          )
          AND expiration_date = (
                SELECT expiration_date
                FROM global_markets.options_greeks
                WHERE underlying_symbol = 'AAPL'
                  AND date = (
                        SELECT max(date)
                        FROM global_markets.options_greeks
                        WHERE underlying_symbol = 'AAPL'
                  )
                  AND days_to_expiry >= 200
                  AND toDayOfWeek(expiration_date) = 5
                GROUP BY expiration_date
                ORDER BY abs(toInt32(max(days_to_expiry)) - 450) ASC
                LIMIT 1
          )
          AND toFloat64(option_close) > 0
          AND toFloat64(strike_price) / toFloat64(underlying_close) BETWEEN 0.50 AND 0.95
          AND modulo(toUInt32(strike_price), 10) = 0
    )
    GROUP BY strike_price
    HAVING countIf(leg = 'call') > 0
       AND countIf(leg = 'put') > 0
    ORDER BY strike_price
    LIMIT 12
)
ORDER BY strike_sort

At the $250 strike the parity rate prints 4.38% a year. Read down the ladder and it barely moves, which is what parity predicts: the rate belongs to the term, not to the strike. The one year Treasury yield on the same session was 4.49%, the cash cost of money over a matching window.

One adjustment stands between that figure and the rate on a margin statement. A shareholder collects dividends; a synthetic holder does not, and the options market prices that give-up into the call and the put before anyone gets there. Adding the forgone stream back raises the comparable rate by 36 basis points (a basis point is one hundredth of a percentage point), to 4.74%. The estimate uses the dividends AAPL paid in the twelve months before that session, in the panel further down.

Does the expiry you pick change the rate?

SELECT
    formatDateTime(expiration_date, '%b %Y')                        AS expiry,
    round(avg(rate_pct), 2)                                         AS parity_rate_pct,
    concat(toString(round(avg(term_days) / 30.44, 1)), ' months')   AS tenor_label,
    toUInt32(count())                                               AS strike_count
FROM
(
    SELECT
        expiration_date,
        strike_price,
        max(days_to_expiry) AS term_days,
        100 * log(toFloat64(strike_price) / (avg(toFloat64(underlying_close))
            - avgIf(toFloat64(option_close), leg = 'call')
            + avgIf(toFloat64(option_close), leg = 'put')))
            / (max(days_to_expiry) / 365.0) AS rate_pct
    FROM
    (
        SELECT
            expiration_date,
            strike_price,
            underlying_close,
            option_close,
            days_to_expiry,
            if(lower(toString(option_type)) LIKE 'c%', 'call', 'put') AS leg
        FROM global_markets.options_greeks
        WHERE underlying_symbol = 'AAPL'
          AND date = (
                SELECT max(date)
                FROM global_markets.options_greeks
                WHERE underlying_symbol = 'AAPL'
          )
          AND toFloat64(option_close) > 0
          AND days_to_expiry BETWEEN 45 AND 600
          AND toDayOfWeek(expiration_date) = 5
          AND toDayOfMonth(expiration_date) BETWEEN 15 AND 21
          AND toFloat64(strike_price) / toFloat64(underlying_close) BETWEEN 0.60 AND 0.90
    )
    GROUP BY expiration_date, strike_price
    HAVING countIf(leg = 'call') > 0
       AND countIf(leg = 'put') > 0
)
GROUP BY expiration_date
HAVING count() >= 2
ORDER BY expiration_date
LIMIT 12

Across the third-Friday expiries in the panel the rate runs from 3.77% on the Nov 2026 contracts to 4.8% on the Jan 2028 contracts, the latter averaged over 7 strikes. Short-dated rows are the noisy ones: a few cents of pricing difference annualizes into a large rate when the term is only a couple of months, which is one practical argument for measuring carry on long-dated contracts. Run the same arithmetic on two index strikes instead of a stock and you get the box spread implied loan rate, which carries no single-stock dividend or borrow component and tends to sit nearer the Treasury curve.

What a margin loan charges

A margin loan is cash borrowed from the broker against the securities in the account, with interest accruing daily on the debit balance. Two pricing shapes dominate. Interactive Brokers quotes a benchmark rate plus a spread that narrows as the debit grows, so a small balance pays the widest spread and an eight-figure balance pays a thin one. Schwab and Fidelity publish a base rate and tier discounts off it; their smallest tiers sat in the low double digits through 2025 and into 2026, while benchmark-plus-spread schedules stayed within a couple of points of the fed funds range over the same stretch. Both kinds of schedule are posted publicly with an effective date, and both reset when the Fed's target range moves, so read the live page and take the tier matching your own balance rather than the headline number.

The account regime matters as much as the tier, since buying power and maintenance requirements differ between the two frameworks in Reg T and portfolio margin.

What the LEAPS route costs that margin does not

SELECT
    ex_date,
    dividend_per_share,
    round(sum(dividend_per_share) OVER (ORDER BY ex_date), 4) AS cumulative_per_share
FROM
(
    SELECT
        ex_dividend_date                      AS ex_date,
        round(max(toFloat64(cash_amount)), 4) AS dividend_per_share
    FROM global_markets.stocks_dividends
    WHERE ticker = 'AAPL'
      AND ex_dividend_date <= (
            SELECT max(date)
            FROM global_markets.options_greeks
            WHERE underlying_symbol = 'AAPL'
      )
      AND ex_dividend_date > subtractDays(
          (
            SELECT max(date)
            FROM global_markets.options_greeks
            WHERE underlying_symbol = 'AAPL'
          ), 365)
    GROUP BY ex_dividend_date
)
ORDER BY ex_date

4 ex dividend dates fall in that window, $1.06 per share in total. A shareholder on margin banks that against the interest bill and a LEAPS holder does not. That is the adjustment applied above; count it once, not twice.

The rest of the gap sits outside the rate.

• The expiry. A margin loan has no maturity date. A LEAPS has one, and staying long past it means rolling into a new contract at whatever the curve offers then.
• The bid ask spread, the gap between the price you can buy at and the price you can sell at. Deep in the money LEAPS quote wide, and each roll crosses it twice, once to close and once to open.
• The fixed rate. Parity locks the financing rate for the life of the contract while a margin rate floats with the benchmark. The lock helps if rates rise over the term and hurts if they fall.
• The downside profile. A long call cannot be margin called and its worst case is the premium paid. A margin debit carries a maintenance requirement and forced liquidation if account equity drops far enough.

Selling shorter-dated calls against the long contract, the poor man's covered call, is one way holders offset the carry. It reshapes the payoff; it does not change the financing rate inside the LEAPS.

LEAPS vs a margin loan: the break even holding period

Neither route front loads the interest. Unused financing stays in the option's time value, and selling early returns most of it. What does not come back is the spread crossed on the way in and out. The break even is a race between a rate difference that accrues with time and a one-time trading cost that does not: divide the round-trip spread cost by the annual rate difference applied to the financed amount, and the answer is the holding period at which the cheaper rate has paid for the friction.

As a hypothetical, on $60,000 financed a one percentage point annual rate advantage is worth $600 a year, about $50 a month. If the round trip on the LEAPS costs $300 in spread, the routes break even about six months in. Halve the rate gap and the break even doubles. Those figures are invented to show the shape of the calculation; the inputs are yours to measure.

The answer rests on assumptions worth stating out loud. The measured rate difference has to hold for the whole window, though a floating margin rate resets whenever the benchmark does. The dividend estimate has to hold, since a raised dividend widens the LEAPS all-in rate after entry. You have to trade near the middle of the quoted spread on entry, exit and every roll. The position has to stay put, as an early assignment, a margin call or a corporate action rewrites the arithmetic mid-stream. And the comparison rate has to be your actual tier rather than the advertised one.

FAQ

Does a LEAPS have an interest rate built into it?

Yes. The premium on a deep in the money call includes the cost of carrying the shares until expiry. That cost is recoverable from the call and the put at the same strike through put call parity, which is what the panels above compute.

How do you calculate the implied financing rate on a LEAPS?

Take the share price, subtract the call, add the put at the same strike and expiry. That sum is the present value of the strike. Divide the strike by it, take the natural log, and divide by the term in years for a continuously compounded annual rate. Add back the dividends the position gives up to get a number comparable with a margin rate.

Is a LEAPS cheaper than buying stock on margin?

It depends on the margin tier actually charged, the dividend yield of the stock, the spread crossed on entry and exit, and the holding period. The panels here settle one pair at one moment; the same queries run on another ticker and expiry produce the current comparison.

Do you receive dividends if you own a LEAPS call?

No. Dividends go to holders of record of the shares. The options market prices the expected stream into calls and puts ahead of each ex date, which is why the raw parity rate on a dividend payer understates the all-in financing cost until the stream is added back.

Why is a deep in the money call cheaper than the shares?

The strike goes unpaid until expiry, so the buyer takes the exposure now and defers most of the purchase price. The premium above intrinsic value is the price of that deferral plus the value of the floor the option provides.

Every panel here ships with the SQL that produced it, expandable underneath. To run the same parity arithmetic on a different ticker or a different expiry, ask for it in plain English on the Strasmore terminal.