Buying Puts vs Buying Calls: Why Puts Cost More

Buying puts vs buying calls looks like one trade and its reflection. The market does not price it that way: at the same distance out of the money, the put on an index or a large-cap name usually costs more, and its break-even sits further from today's price. The move also has to arrive faster to pay. This post assumes you already know what a put option is and what a call option is, and spends all of its space on the places where the two sides come apart.

Are buying puts and buying calls mirror images?

A call is the right to buy at a fixed strike. A put is the right to sell at one. Drawn as payoff diagrams the two are reflections, which is where the intuition comes from. Four things break the reflection once real prices are attached. The price per unit of distance out of the money differs between the sides. The arithmetic at a shared strike, pinned by put-call parity, differs between the sides. Volatility itself behaves differently while a market falls than while it rises. And the flow standing behind the downside bid runs all year, while the upside bid arrives in bursts. Each one has a measured number under it below.

Why are puts more expensive than calls?

Implied volatility is the annualised move a contract's price implies. It is the unit that lets a $4 option at one strike be compared with a $1 option at another. Take two contracts the same distance from the current price, one below it and one above it, and any difference in implied volatility is the market quoting the two directions at different rates. That tilt has a name: volatility skew.

The panel below walks outward from the money in two-point steps and prices each step on both sides of the S&P 500 tracker, SPY, over the three months through August 2026.

SELECT
    concat(toString(otm_bin), '%')                                       AS otm_distance,
    round(avgIf(iv, side = 'put') * 100, 2)                              AS put_iv_pct,
    round(avgIf(iv, side = 'call') * 100, 2)                             AS call_iv_pct,
    round((avgIf(iv, side = 'put') - avgIf(iv, side = 'call')) * 100, 2) AS put_minus_call_pct
FROM
(
    SELECT
        if(lower(option_type) LIKE 'p%', 'put', 'call')                  AS side,
        toFloat64(implied_volatility)                                    AS iv,
        toInt32(round(abs(toFloat64(strike_price) / toFloat64(underlying_close) - 1) * 50) * 2) AS otm_bin
    FROM global_markets.options_greeks
    WHERE underlying_symbol = 'SPY'
      AND date >= '2026-06-01'
      AND date <  '2026-09-01'
      AND iv_converged = 1
      AND volume > 0
      AND days_to_expiry BETWEEN 20 AND 45
      AND abs(toFloat64(strike_price) / toFloat64(underlying_close) - 1) <= 0.10
      AND ((lower(option_type) LIKE 'p%'     AND toFloat64(strike_price) <= toFloat64(underlying_close))
        OR (lower(option_type) NOT LIKE 'p%' AND toFloat64(strike_price) >= toFloat64(underlying_close)))
)
GROUP BY otm_bin
HAVING countIf(side = 'put') > 0 AND countIf(side = 'call') > 0
ORDER BY otm_bin

At the money the two sides sit close together: 14.73% on the put against 13.37% on the call, 1.35 volatility points apart. Walk out to 10% from spot and the put carries 23.51% against 12.85% on the call, a gap of 10.66 points. The curve covers 6 distance steps, and the shape is the lesson: the further out the strike, the more the two sides disagree about what an identically sized move is worth.

What the skew does to the break-even

A long call reaches break-even at expiry above the strike plus the premium paid. A long put reaches it below the strike minus the premium. Expressed as a percentage move from the price on the day of purchase, that is how far the underlying has to travel before the position returns the cash that went into it.

SELECT
    dte_band                                                                      AS dte_band,
    round(avgIf(breakeven_move_pct, side = 'put'), 2)                             AS put_breakeven_move_pct,
    round(avgIf(breakeven_move_pct, side = 'call'), 2)                            AS call_breakeven_move_pct,
    round(avgIf(breakeven_move_pct, side = 'put') - avgIf(breakeven_move_pct, side = 'call'), 2) AS put_extra_move_pct
FROM
(
    SELECT
        if(lower(option_type) LIKE 'p%', 'put', 'call')                           AS side,
        multiIf(days_to_expiry <= 14, '7 to 14 days',
                days_to_expiry <= 30, '15 to 30 days',
                days_to_expiry <= 60, '31 to 60 days',
                                      '61 to 90 days')                            AS dte_band,
        multiIf(days_to_expiry <= 14, 1,
                days_to_expiry <= 30, 2,
                days_to_expiry <= 60, 3,
                                      4)                                          AS band_order,
        if(lower(option_type) LIKE 'p%',
           (toFloat64(underlying_close) - toFloat64(strike_price) + toFloat64(option_close)) / toFloat64(underlying_close) * 100,
           (toFloat64(strike_price) + toFloat64(option_close) - toFloat64(underlying_close)) / toFloat64(underlying_close) * 100) AS breakeven_move_pct
    FROM global_markets.options_greeks
    WHERE underlying_symbol = 'SPY'
      AND date >= '2026-06-01'
      AND date <  '2026-09-01'
      AND volume > 0
      AND option_close > 0
      AND days_to_expiry BETWEEN 7 AND 90
      AND ((lower(option_type) LIKE 'p%'     AND toFloat64(strike_price) / toFloat64(underlying_close) BETWEEN 0.94 AND 0.96)
        OR (lower(option_type) NOT LIKE 'p%' AND toFloat64(strike_price) / toFloat64(underlying_close) BETWEEN 1.04 AND 1.06))
)
GROUP BY dte_band, band_order
HAVING countIf(side = 'put') > 0 AND countIf(side = 'call') > 0
ORDER BY band_order

Both legs start 5% out of the money, so every difference in the break-even is premium and nothing else. At 7 to 14 days to expiry, the put needed a fall of 5.03% against a rise of 4.89% on the call, a spread of 0.14 percentage points. At 61 to 90 days, with more premium sitting in both contracts, the put needed 6.19% against 5.84%, a spread of 0.35 points. Tenths of a percent sound like rounding. They are the distance between a put that finishes a few cents in the money and one that finishes at zero.

What put-call parity pins down at a shared strike

Move both legs onto the same strike and the relationship stops being a matter of opinion. Parity is an identity: the call price minus the put price equals the current price minus the present value of the strike, less any dividends paid over the life of the contract. The financing leg lifts the forward price above spot. The dividend leg pulls it back down. Whichever leg wins decides which option is dearer at that shared strike, and no view on direction enters into it. This is a separate effect from the skew above and it can point the other way: skew is priced per distance from spot, parity is arithmetic at one strike.

WITH
puts AS
(
    SELECT
        underlying_symbol,
        date,
        strike_price,
        expiration_date,
        toFloat64(option_close)                                     AS put_close,
        toFloat64(underlying_close)                                 AS spot
    FROM global_markets.options_greeks
    WHERE lower(option_type) LIKE 'p%'
      AND underlying_symbol IN ('SPY', 'AAPL', 'MSFT', 'NVDA', 'KO', 'XOM')
      AND date >= '2026-06-01'
      AND date <  '2026-09-01'
      AND volume > 0
      AND days_to_expiry BETWEEN 25 AND 45
      AND abs(toFloat64(strike_price) / toFloat64(underlying_close) - 1) < 0.005
),
calls AS
(
    SELECT
        underlying_symbol,
        date,
        strike_price,
        expiration_date,
        toFloat64(option_close)                                     AS call_close
    FROM global_markets.options_greeks
    WHERE lower(option_type) NOT LIKE 'p%'
      AND underlying_symbol IN ('SPY', 'AAPL', 'MSFT', 'NVDA', 'KO', 'XOM')
      AND date >= '2026-06-01'
      AND date <  '2026-09-01'
      AND volume > 0
      AND days_to_expiry BETWEEN 25 AND 45
)
SELECT
    p.underlying_symbol                                             AS ticker,
    round(avg(p.put_close / p.spot) * 100, 3)                       AS put_pct_of_spot,
    round(avg(c.call_close / p.spot) * 100, 3)                      AS call_pct_of_spot,
    round(avg((p.put_close - c.call_close) / p.spot) * 100, 3)      AS put_minus_call_pct_of_spot
FROM puts AS p
INNER JOIN calls AS c
    ON  p.underlying_symbol = c.underlying_symbol
    AND p.date              = c.date
    AND p.strike_price      = c.strike_price
    AND p.expiration_date   = c.expiration_date
GROUP BY ticker
ORDER BY put_minus_call_pct_of_spot DESC

Each row pairs every at-the-money put with the call on the identical strike and expiry, 25 to 45 days out, over the three months through August 2026. XOM sits at the top of the ladder at 0.185% of the share price, with the put averaging 3.691% of spot against 3.506% for the call. AAPL anchors the other end at -0.441%. The ranking tracks the cash each name pays out over the window set against what the financing leg adds, which is why a shared strike is the only place this comparison can be made cleanly.

What volatility does while a market falls

Realised volatility is what actually happened: the standard deviation of daily moves over a window, scaled to a year. The panel groups every month of SPY history since 2006 by that month's own return, then averages the realised volatility measured inside those months.

WITH
daily AS
(
    SELECT
        date                                                                                      AS d,
        toFloat64(close) / lagInFrame(toFloat64(close)) OVER (ORDER BY date ASC ROWS BETWEEN 1 PRECEDING AND CURRENT ROW) - 1 AS ret
    FROM global_markets.stocks_daily_aggs
    WHERE ticker = 'SPY'
      AND date >= '2006-01-01'
      AND date <  '2026-09-01'
),
months AS
(
    SELECT
        toStartOfMonth(d)                            AS month,
        (exp(sum(log(1 + ret))) - 1) * 100           AS month_return_pct,
        stddevPop(ret) * sqrt(252) * 100             AS realised_vol_pct,
        count()                                      AS sessions
    FROM daily
    WHERE abs(ret) < 0.5
    GROUP BY month
    HAVING sessions >= 15
)
SELECT
    multiIf(month_return_pct < -5, 'fell more than 5%',
            month_return_pct <  0, 'fell 0 to 5%',
            month_return_pct <  5, 'rose 0 to 5%',
                                   'rose more than 5%') AS month_return_band,
    round(avg(realised_vol_pct), 2)                     AS avg_realised_vol_pct,
    count()                                             AS months
FROM months
GROUP BY month_return_band
ORDER BY min(month_return_pct) ASC

Months that fell more than 5% averaged 31.65% annualised realised volatility, across 26 such months. Months that rose more than 5% averaged 16.14% over 36 months. Declines and turbulence show up together in the same months; advances tend to be the quieter ones. The 4 bands walk from the worst months to the best.

That pattern is what the put's extra premium is charging for, and it sets the trap inside a long put. The price embeds a fast decline. A market that drifts 4% lower over two months can leave a put bought 5% out of the money worthless at expiry while the holder had the direction right the whole way. A call buyer meets a gentler version of the same problem: a slow grind higher still arrives, and it was priced off a lower implied path at the outset.

Is the bid for downside protection persistent?

Delta measures roughly how much an option's price moves per $1 in the underlying. The 25-delta contracts on each side, a put with delta near -0.25 and a call near +0.25, are the conventional wings of the curve, and the distance between their implied volatilities is the standard skew reading.

SELECT
    toString(toStartOfMonth(date))                                                       AS month,
    round(avgIf(toFloat64(implied_volatility), delta BETWEEN -0.30 AND -0.20) * 100, 2)  AS put_25d_iv_pct,
    round(avgIf(toFloat64(implied_volatility), delta BETWEEN  0.20 AND  0.30) * 100, 2)  AS call_25d_iv_pct,
    round((avgIf(toFloat64(implied_volatility), delta BETWEEN -0.30 AND -0.20)
         - avgIf(toFloat64(implied_volatility), delta BETWEEN  0.20 AND  0.30)) * 100, 2) AS skew_spread_pct
FROM global_markets.options_greeks
WHERE underlying_symbol = 'SPY'
  AND date >= '2024-09-01'
  AND date <  '2026-09-01'
  AND iv_converged = 1
  AND volume > 0
  AND days_to_expiry BETWEEN 20 AND 45
GROUP BY month
HAVING countIf(delta BETWEEN -0.30 AND -0.20) > 0
   AND countIf(delta BETWEEN 0.20 AND 0.30) > 0
ORDER BY month

Across the 24 months through August 2026, the wing spread opened the window at 5.61 volatility points and closed it at 4.42, with the 25-delta put at 15.38% against 10.97% on the call in the final month. Hedging is a standing requirement for institutions holding equity, and the line on that chart is what a standing requirement looks like when it meets demand that comes and goes on the other side.

Buying puts vs buying calls: which view does each one fit?

Put the four pieces together and the chooser is plain. A long put is a position on a decline that arrives quickly, since the premium pays for the direction and the speed at once. A long call is a position on a rise that is allowed to take its time. At equal distance from the money the put costs more and starts further from break-even, so it has to be more right to return the same money.

Maximum loss is the one place where the two really are symmetric. On either a long call or a long put, the most that can be lost is the premium paid plus fees, whatever the underlying does afterwards. A long option is a right and never an obligation, so the holder can let it expire and walk away. Buying and selling put options covers the other side of that trade, where the loss profile is not symmetric at all.

FAQ

Is buying a put the same as buying a call on the way down?

No. The payoff diagrams mirror each other and the prices do not. On index and large-cap names the same distance out of the money costs more on the put side, which pushes the put's break-even further from the current price. The put also carries more of a bet on speed, since the contract loses to time while a slow decline plays out.

Why are puts more expensive than calls?

At equal distance from the money, puts on most index and large-cap underlyings carry higher implied volatility than calls, a tilt known as volatility skew. Standing hedging demand from holders of equity sits on the put side all year, while call buying arrives in bursts. The first panel above measures the gap on SPY over the three months through August 2026.

What is the maximum loss on a long put or a long call?

The premium paid, plus any fees. That ceiling is identical on both sides and it holds no matter how far the underlying moves against the position. It is the one piece of the put-versus-call comparison that is genuinely symmetric.

Can a put lose money when the stock falls?

Yes. An out-of-the-money put needs the price to travel past the strike and then past the premium before expiry. A decline slower or shallower than the implied path priced into the contract can leave the put worthless with the direction call correct all along.

Does put-call parity mean puts and calls cost the same?

No. Parity pins the gap between a call and a put at one shared strike and expiry to the cost of carry: the present value of the strike set against the current price, less dividends over the contract's life. It says nothing about two contracts at different strikes, which is where skew lives.

Every panel above ships with the exact SQL that produced it. To price the same distance on both sides of a name you follow, ask the question in plain English on the Strasmore terminal.