Margin for Selling Naked Options: Reg T Math

Margin for selling naked options comes out of a published formula, and you can compute it yourself before the trade goes on. The minimum for one uncovered equity option is the greater of two branches, each with the premium received added on top: 20% of the underlying share price minus the amount the option is out of the money, or a floor of 10%. Every percentage on this page is a regulatory minimum. A broker is free to hold an account to more, and most do.

How is margin for selling naked options calculated?

An option is uncovered, or naked, when it has been sold with nothing behind it: a short call with no shares in the account, or a short put with no cash set aside against the strike. A cash secured put parks the full strike value instead, a different arrangement with a different requirement.

Regulation T sets the credit rules for a margin account. The uncovered option percentages themselves live in FINRA Rule 4210 and the exchange margin manuals that mirror it. The arithmetic works per share, then gets charged per contract of 100 shares:

• Uncovered call, first branch: premium received, plus 20% of the underlying price, minus the out of the money amount (strike minus underlying, floored at zero).
• Uncovered put, first branch: premium received, plus 20% of the underlying price, minus the out of the money amount (underlying minus strike, floored at zero).
• Floor branch for a call: premium received plus 10% of the underlying price.
• Floor branch for a put: premium received plus 10% of the strike price.

The requirement is whichever comes out larger. Broad based index options run the same shape with 15% in place of 20%. Selling uncovered also takes a margin account with the right option approval level, and a margin account brings the pattern day trader rule along with it.

The premium sits in both branches, so it lifts the whole number without changing which branch binds. Distance is what decides that. For a call the two branches are equal when the strike sits exactly 10% above the underlying. For a put they are equal when the strike sits about 11.1% below it. Inside those distances the 20% branch is larger. Past them the floor takes over.

Why the 20% branch and the 10% floor cross

The panel below walks every listed AAPL strike on the last session of June 2026, from just under the share price out to roughly 18% above it, taking contracts 20 to 45 days from expiry. It computes both branches per share for an uncovered call at each strike. The premium is left out here to keep the shape clean. Adding it shifts both lines up together.

SELECT
    round(toFloat64(strike_price), 2)                                          AS strike,
    round(0.20 * max(toFloat64(underlying_close))
          - greatest(toFloat64(strike_price) - max(toFloat64(underlying_close)), 0.0), 2) AS main_branch,
    round(0.10 * max(toFloat64(underlying_close)), 2)                          AS floor_branch,
    round(0.20 * max(toFloat64(underlying_close))
          - greatest(toFloat64(strike_price) - max(toFloat64(underlying_close)), 0.0)
          - 0.10 * max(toFloat64(underlying_close)), 2)                        AS branch_gap
FROM global_markets.options_greeks
WHERE underlying_symbol = 'AAPL'
  AND date = (
      SELECT max(date)
      FROM global_markets.options_greeks
      WHERE underlying_symbol = 'AAPL'
        AND date BETWEEN '2026-06-01' AND '2026-06-30'
  )
  AND days_to_expiry BETWEEN 20 AND 45
  AND iv_converged = 1
  AND volume > 0
  AND toFloat64(strike_price) BETWEEN 0.98 * toFloat64(underlying_close)
                                  AND 1.18 * toFloat64(underlying_close)
GROUP BY strike_price
ORDER BY strike

The floor line is flat. Ten percent of the share price does not care where the strike is, so it holds at $28.9 a share across all 12 strikes in the panel. The first branch slopes down, from $57.8 at the lowest strike to $6.81 at the highest, since every dollar of extra distance comes straight off it. The branch_gap column is the first branch minus the floor: above zero where the 20% branch binds, below zero where the floor does, and it crosses at the strike 10% above the share price.

How much margin does a naked put need?

Same first branch, different floor: 10% of the strike rather than 10% of the underlying. That single substitution changes the picture. The floor stops being a flat line and slopes with the strike, and the crossing point moves to roughly 11% below the share price.

SELECT
    round(toFloat64(strike_price), 2)                                          AS strike,
    round(0.20 * max(toFloat64(underlying_close))
          - greatest(max(toFloat64(underlying_close)) - toFloat64(strike_price), 0.0), 2) AS main_branch,
    round(0.10 * toFloat64(strike_price), 2)                                   AS floor_branch,
    round(0.20 * max(toFloat64(underlying_close))
          - greatest(max(toFloat64(underlying_close)) - toFloat64(strike_price), 0.0)
          - 0.10 * toFloat64(strike_price), 2)                                 AS branch_gap
FROM global_markets.options_greeks
WHERE underlying_symbol = 'AAPL'
  AND date = (
      SELECT max(date)
      FROM global_markets.options_greeks
      WHERE underlying_symbol = 'AAPL'
        AND date BETWEEN '2026-06-01' AND '2026-06-30'
  )
  AND days_to_expiry BETWEEN 20 AND 45
  AND iv_converged = 1
  AND volume > 0
  AND toFloat64(strike_price) BETWEEN 0.82 * toFloat64(underlying_close)
                                  AND 1.02 * toFloat64(underlying_close)
GROUP BY strike_price
ORDER BY strike

Across the put strikes here the floor runs from $24 a share at the lowest strike to $29 at the highest, while the first branch climbs as the strike approaches the money. Far below the market, where sellers running the wheel strategy often work, the floor is the binding number. That floor is what keeps a deep out of the money naked put from ever being free to carry.

How much buying power does one naked contract tie up?

Per share figures are the formula. Per contract figures are what leaves the account. The panel takes 5 household names on the same June 2026 session, picks the listed call strike closest to 5% above each share price, and multiplies both branches by the 100 shares a contract covers.

SELECT
    ticker,
    round(100 * (0.20 * share_price - greatest(strike - share_price, 0.0)), 0) AS main_branch,
    round(100 * (0.10 * share_price), 0)                                       AS floor_branch
FROM
(
    SELECT
        underlying_symbol                AS ticker,
        max(toFloat64(underlying_close)) AS share_price,
        argMin(toFloat64(strike_price),
               abs(toFloat64(strike_price) / toFloat64(underlying_close) - 1.05)) AS strike
    FROM global_markets.options_greeks
    WHERE underlying_symbol IN ('AAPL', 'MSFT', 'NVDA', 'SPY', 'KO')
      AND date = (
          SELECT max(date)
          FROM global_markets.options_greeks
          WHERE underlying_symbol = 'SPY'
            AND date BETWEEN '2026-06-01' AND '2026-06-30'
      )
      AND days_to_expiry BETWEEN 20 AND 45
      AND iv_converged = 1
      AND volume > 0
    GROUP BY underlying_symbol
)
ORDER BY main_branch DESC

One uncovered SPY call at that distance carries a $11156 minimum for a single contract, against $1252 for KO. Identical trade, identical formula. The number tracks the share price rather than anything about the option itself. At 5% out of the money the first branch binds for every name here, and the taller bar in each pair is the one that counts.

Check any position with a short Python script

The formula fits in a file. This needs python3 and nothing else: standard library only, no pip install, no network. Save it as naked_margin.py.

#!/usr/bin/env python3
"""Reg T style minimum for one uncovered (naked) equity option.

Prints both branches of the requirement and the one that binds.
Standard library only. Educational, not a broker quote.
"""
import argparse

SHARES_PER_CONTRACT = 100


def branches(kind, spot, strike, premium, rule_pct, floor_pct):
    if kind == 'call':
        out_of_money = max(strike - spot, 0.0)
        floor_base = spot
    else:
        out_of_money = max(spot - strike, 0.0)
        floor_base = strike
    rule = rule_pct * spot - out_of_money + premium
    floor = floor_pct * floor_base + premium
    return rule, floor


def report(kind, spot, strike, premium, rule_pct, floor_pct):
    rule, floor = branches(kind, spot, strike, premium, rule_pct, floor_pct)
    if rule >= floor:
        binds = '{0:.0%} branch'.format(rule_pct)
    else:
        binds = '{0:.0%} floor'.format(floor_pct)
    print('naked {0}: spot {1:.2f}, strike {2:.2f}, premium {3:.2f}'.format(
        kind, spot, strike, premium))
    print('  {0:.0%} branch: {1:.2f} per share, {2:.2f} per contract'.format(
        rule_pct, rule, rule * SHARES_PER_CONTRACT))
    print('  {0:.0%} floor:  {1:.2f} per share, {2:.2f} per contract'.format(
        floor_pct, floor, floor * SHARES_PER_CONTRACT))
    print('  binds: {0}, requirement {1:.2f} per contract'.format(
        binds, max(rule, floor) * SHARES_PER_CONTRACT))


def main():
    ap = argparse.ArgumentParser(description='Reg T style naked option minimum')
    ap.add_argument('--spot', type=float, required=True, help='underlying price')
    ap.add_argument('--strike', type=float, required=True, help='strike price')
    ap.add_argument('--premium', type=float, required=True, help='premium per share')
    ap.add_argument('--index', action='store_true', help='broad based index rate')
    args = ap.parse_args()
    rule_pct = 0.15 if args.index else 0.20
    for kind in ('call', 'put'):
        report(kind, args.spot, args.strike, args.premium, rule_pct, 0.10)


if __name__ == '__main__':
    main()

Two runs, picked so the binding branch flips between them. Both use round hypothetical inputs.

$ python3 naked_margin.py --spot 100 --strike 105 --premium 1.50
naked call: spot 100.00, strike 105.00, premium 1.50
  20% branch: 16.50 per share, 1650.00 per contract
  10% floor:  11.50 per share, 1150.00 per contract
  binds: 20% branch, requirement 1650.00 per contract
naked put: spot 100.00, strike 105.00, premium 1.50
  20% branch: 21.50 per share, 2150.00 per contract
  10% floor:  12.00 per share, 1200.00 per contract
  binds: 20% branch, requirement 2150.00 per contract

$ python3 naked_margin.py --spot 100 --strike 85 --premium 0.60
naked call: spot 100.00, strike 85.00, premium 0.60
  20% branch: 20.60 per share, 2060.00 per contract
  10% floor:  10.60 per share, 1060.00 per contract
  binds: 20% branch, requirement 2060.00 per contract
naked put: spot 100.00, strike 85.00, premium 0.60
  20% branch: 5.60 per share, 560.00 per contract
  10% floor:  9.10 per share, 910.00 per contract
  binds: 10% floor, requirement 910.00 per contract

In the first run the strike sits 5% above the underlying, inside the 10% crossover, and the first branch binds for the call and the put alike. In the second the strike is 15% below the underlying, which leaves the call in the money on the first branch and pushes the put far enough out that the 10% floor takes the position. Feed it your own inputs with --spot, --strike and --premium, and add --index for the 15% broad based index figure. What it prints is a floor on what a broker will ask, never a ceiling.

What changes the requirement after you sell

The number is not set once. It is recomputed against the underlying price daily, and the underlying moves. The trace below fixes a short call strike about 10% above where AAPL opened April 2026, then follows the requirement as a percent of the share price through the end of June.

SELECT
    toString(d.dt)                                               AS session_date,
    round(d.px, 2)                                               AS underlying_close,
    round(100 * (s.short_strike - d.px) / d.px, 2)               AS cushion_pct,
    round(100 * greatest(0.20 * d.px - greatest(s.short_strike - d.px, 0.0),
                         0.10 * d.px) / d.px, 2)                 AS requirement_pct
FROM
(
    SELECT
        date                             AS dt,
        max(toFloat64(underlying_close)) AS px
    FROM global_markets.options_greeks
    WHERE underlying_symbol = 'AAPL'
      AND date BETWEEN '2026-04-01' AND '2026-06-30'
    GROUP BY date
) AS d
CROSS JOIN
(
    SELECT round(1.10 * argMin(toFloat64(underlying_close), date), 0) AS short_strike
    FROM global_markets.options_greeks
    WHERE underlying_symbol = 'AAPL'
      AND date BETWEEN '2026-04-01' AND '2026-06-30'
) AS s
ORDER BY d.dt

The position starts life sitting on the crossover, at 10.19% of the share price with 9.81% of headroom to the strike, and finishes the window at 20%. As a stock climbs toward a short call strike the out of the money subtraction shrinks, and the requirement walks up toward the full 20%. Four other things move it:

• Assignment ends the option and hands over stock or a short stock position with its own requirement. Early assignment on short options clusters around dividends and deep in the money strikes.
• House requirements sit on top of the minimum. Brokers routinely set their own figures above Reg T for uncovered positions, sometimes a multiple of it on volatile names.
• A move against the position lifts the requirement while account equity falls at the same time. The gap between the two is what produces a maintenance call.
• Portfolio margin is a separate regime. An approved account is charged off a stress test of the whole book, on the order of a 15% move up or down in an equity underlying, with a six figure account minimum at most brokers. For a hedged book the figure can land far below Reg T, and it moves faster when volatility rises.

None of this is a recommendation. Uncovered selling carries loss that is unbounded on the call side and very large on the put side, and how risky options trading is walks through that distribution with data.

FAQ

How much margin do I need to sell a naked put?

The regulatory minimum is the greater of two branches, both including the premium received: 20% of the underlying price minus the out of the money amount, or 10% of the strike price. On a $100 stock, a $90 strike put sold for $0.60 works out to $10.60 a share against a $9.60 floor, so $1,060 for one contract. Brokers commonly require more.

Is naked option margin the same at every broker?

No. Reg T and FINRA Rule 4210 set the minimum, and every broker may add a house requirement above it. Many do on single names and around earnings dates. The published formula gives you the bottom of the range, not the number your platform will display.

Does the premium I collect count toward the requirement?

The premium received is added to both branches of the formula and is credited to the account when the trade settles. It never changes which branch binds, since it appears on both sides in equal amount.

What is the margin for a naked index option?

Broad based index options carry 15% in place of 20%, with the same 10% floor and the same premium term. Options on an ETF that tracks a broad index are treated as equity options at the 20% figure, so the lower percentage does not follow the exposure across wrappers. Both remain regulatory minimums.

Can a naked option requirement change while I hold it?

Yes. It is recomputed off the underlying price, so it moves whenever the stock moves, as the trace above shows. A rise toward a short call strike lifts the number, and a broker may raise its house requirement on an open position as well.

Every panel here carries the SQL that produced it, so expand any one to see exactly how a branch was computed. To run the same chain math on a name you follow, ask for it in plain English on the Strasmore terminal.