By Buy a Call or Sell a Put: Payoff and Risk
Buy a call or sell a put? Both lean bullish, yet the max loss and the cash tied up differ sharply. See both payoffs on one grid, priced from real option data.
Buy a call or sell a put? Both lean bullish on the same stock over the same weeks, and both carry positive delta, the amount an option's price moves for a one dollar move in the shares. The payoff shapes are nothing alike. A long call pays a premium and stops losing right there. A short put collects a premium and stays exposed all the way down to a zero share price.
Buy a call or sell a put on one payoff grid
The panel below pins one real pair of contracts: an at the money AAPL call and the put at the same strike and the same expiration, both read from a single closing session.
The exact SQL behind every number
WITH pair AS
(
SELECT
toDate(date) AS d,
toDate(expiration_date) AS exp,
toFloat64(strike_price) AS strike,
anyIf(toFloat64(option_close), upper(toString(option_type)) LIKE 'C%') AS call_px,
anyIf(toFloat64(option_close), upper(toString(option_type)) LIKE 'P%') AS put_px
FROM global_markets.options_greeks
WHERE underlying_symbol = 'AAPL'
AND toDate(date) =
(
SELECT max(toDate(date))
FROM global_markets.options_greeks
WHERE toDate(date) < today()
AND toDate(date) >= today() - 400
)
AND dateDiff('day', toDate(date), toDate(expiration_date)) BETWEEN 20 AND 60
GROUP BY d, exp, strike
HAVING call_px > 0 AND put_px > 0
ORDER BY abs(dateDiff('day', d, exp) - 35) ASC, abs(call_px - put_px) ASC, strike ASC
LIMIT 1
)
SELECT
concat(formatDateTime(d, '%b'), ' ', toString(toDayOfMonth(d)), ', ', toString(toYear(d))) AS session,
concat(formatDateTime(exp, '%b'), ' ', toString(toDayOfMonth(exp)), ', ', toString(toYear(exp))) AS expiry,
toInt32(dateDiff('day', d, exp)) AS days_to_expiry,
round(strike, 2) AS atm_strike,
round(call_px, 2) AS call_price,
round(put_px, 2) AS put_price
FROM pairAt the money here means the listed strike where the call and the put are marked closest together, which put call parity places right about where the shares are trading. On the Aug 18, 2026 close that strike was $310, with 38 days left to the Sep 25, 2026 expiration, the call marked at $10.48 a share and the put at $8.85. The grid walks the share price from 20% under that strike to 20% over it, printing what each position is worth at expiration per contract of 100 shares. The third line adds the two together.
The exact SQL behind every number
WITH pair AS
(
SELECT
toDate(date) AS d,
toDate(expiration_date) AS exp,
toFloat64(strike_price) AS strike,
anyIf(toFloat64(option_close), upper(toString(option_type)) LIKE 'C%') AS call_px,
anyIf(toFloat64(option_close), upper(toString(option_type)) LIKE 'P%') AS put_px
FROM global_markets.options_greeks
WHERE underlying_symbol = 'AAPL'
AND toDate(date) =
(
SELECT max(toDate(date))
FROM global_markets.options_greeks
WHERE toDate(date) < today()
AND toDate(date) >= today() - 400
)
AND dateDiff('day', toDate(date), toDate(expiration_date)) BETWEEN 20 AND 60
GROUP BY d, exp, strike
HAVING call_px > 0 AND put_px > 0
ORDER BY abs(dateDiff('day', d, exp) - 35) ASC, abs(call_px - put_px) ASC, strike ASC
LIMIT 1
)
SELECT
concat('$', toString(toUInt32(px))) AS price_at_expiry,
round(100 * (greatest(px - strike, 0) - call_px), 0) AS long_call_pnl,
round(100 * (put_px - greatest(strike - px, 0)), 0) AS short_put_pnl,
round(100 * ((greatest(px - strike, 0) - call_px)
+ (put_px - greatest(strike - px, 0))), 0) AS combined_pnl
FROM
(
SELECT
strike,
call_px,
put_px,
arrayJoin(arrayMap(i -> round(strike * (0.80 + i * 0.02)), range(21))) AS px
FROM pair
)
ORDER BY pxStart at the left edge. At $248 a share the long call is worth -1048 dollars and the short put is worth -5315 dollars. The call line has already gone flat: it holds that value at every price under the strike, and the premium paid is the whole of the loss. The put line keeps sliding for as long as the share price keeps falling.
Now the right edge. At $372 the call is worth 5152 dollars and it keeps climbing with the stock. The short put has flattened at 885 dollars, the credit collected, and it stays there whether the shares finish 20% higher or three times higher.
Breakeven follows the same geometry. A long call turns positive above the strike plus the premium paid, so the shares have to move for the trade to pay. A short put stays positive anywhere above the strike minus the credit received, a lower bar. The put seller is paid on quiet tape and on mild declines. The call buyer is paid on the big move. Each leg on its own is covered in buying and selling call options and buying and selling put options.
Where does the loss stop?
The long call's worst case is fixed at the fill. Whatever the premium was, that is the loss, and it lands if the shares close at or under the strike on expiration day. On the grid it is the flat left half of the call line at -1048 dollars.
The short put's worst case is the strike less the credit, per share, and it arrives at a zero share price. The left edge of this grid is only a 20% decline, and the short put already stands at -5315 dollars there against a best case of 885. The credit is the ceiling and it never grows. The ratio between those two numbers describes the position better than the credit on its own.
A second asymmetry hides in the short put. US listed equity options are American style, so the holder can exercise on any business day up to expiration and deliver 100 shares per contract to the seller at the strike. The call buyer picks the moment of exercise. The put seller takes whatever moment arrives, and a strike sitting near the money into the close carries pin risk on top.
How do theta and implied volatility differ between them?
Two more numbers split the pair, and they carry opposite signs. Theta is the value an option loses per day from the calendar alone. Vega is the value it gains or loses when implied volatility, the market's priced expectation of future movement, changes by one point. The panel walks out the expiration calendar from the same AAPL session, holding the strike near the money at each stop.
The exact SQL behind every number
WITH per_strike AS
(
SELECT
toDate(expiration_date) AS exp,
toInt32(dateDiff('day', toDate(date), toDate(expiration_date))) AS days,
toFloat64(strike_price) AS strike,
anyIf(toFloat64(option_close), upper(toString(option_type)) LIKE 'C%') AS call_px,
anyIf(toFloat64(option_close), upper(toString(option_type)) LIKE 'P%') AS put_px,
anyIf(toFloat64(theta), upper(toString(option_type)) LIKE 'C%') AS call_theta,
anyIf(toFloat64(theta), upper(toString(option_type)) LIKE 'P%') AS put_theta,
anyIf(toFloat64(vega), upper(toString(option_type)) LIKE 'C%') AS call_vega,
anyIf(toFloat64(vega), upper(toString(option_type)) LIKE 'P%') AS put_vega
FROM global_markets.options_greeks
WHERE underlying_symbol = 'AAPL'
AND toDate(date) =
(
SELECT max(toDate(date))
FROM global_markets.options_greeks
WHERE toDate(date) < today()
AND toDate(date) >= today() - 400
)
AND dateDiff('day', toDate(date), toDate(expiration_date)) BETWEEN 5 AND 130
GROUP BY exp, days, strike
HAVING call_px > 0 AND put_px > 0
)
SELECT
concat(toString(any(days)), ' days') AS dte,
round(argMin(call_theta, abs(call_px - put_px)), 4) AS long_call_theta,
round(-argMin(put_theta, abs(call_px - put_px)), 4) AS short_put_theta,
round(argMin(call_vega, abs(call_px - put_px)), 4) AS long_call_vega,
round(-argMin(put_vega, abs(call_px - put_px)), 4) AS short_put_vega
FROM per_strike
GROUP BY exp
ORDER BY exp
LIMIT 12At the front expiration the long call's theta is -0.3071 per share per day and the short put's is 0.284. Time drains one position and pays the other. Vega splits the same way: long call vega runs 0.1584 at the front and 0.6278 out at 94 days, while the short put's vega sits on the other side of zero at every stop on the grid.
The practical effect: with the share price unchanged, a fall in implied volatility takes value out of the long call and hands value to the short put. A rise does the reverse. Two positions can share a bullish delta while one is long volatility and the other is short it. Implied volatility measured against realized movement is the other half of that comparison.
How much cash does each one tie up?
A call buyer pays the premium and the account is done with it. A put seller either reserves the full strike in cash, which makes it a cash secured put, or posts margin and lives with a requirement that moves with the share price. The next two panels price the same trade across 6 household names on that same session, each with an expiration about five weeks out and the strike nearest the money in that name.
The exact SQL behind every number
WITH atm AS
(
SELECT
ticker,
days,
strike,
call_px,
put_px,
abs(days - 35) * 100000 + abs(call_px - put_px) AS rank_key
FROM
(
SELECT
underlying_symbol AS ticker,
toInt32(dateDiff('day', toDate(date), toDate(expiration_date))) AS days,
toFloat64(strike_price) AS strike,
anyIf(toFloat64(option_close), upper(toString(option_type)) LIKE 'C%') AS call_px,
anyIf(toFloat64(option_close), upper(toString(option_type)) LIKE 'P%') AS put_px
FROM global_markets.options_greeks
WHERE underlying_symbol IN ('AAPL', 'JPM', 'KO', 'MSFT', 'NVDA', 'SPY')
AND toDate(date) =
(
SELECT max(toDate(date))
FROM global_markets.options_greeks
WHERE toDate(date) < today()
AND toDate(date) >= today() - 400
)
AND dateDiff('day', toDate(date), toDate(expiration_date)) BETWEEN 20 AND 60
GROUP BY ticker, days, strike
HAVING call_px > 0 AND put_px > 0
)
)
SELECT
ticker,
round(100 * argMin(call_px, rank_key), 0) AS call_cost,
round(100 * argMin(put_px, rank_key), 0) AS put_credit
FROM atm
GROUP BY ticker
ORDER BY tickerIn AAPL the call costs 1048 dollars per contract and the put pays 885 dollars. The two bars stay in the same neighborhood in every name on the panel, which is put call parity at work: at a shared strike and expiration, the call and the put are tied to each other through the share price and the strike. The cash standing behind them is nowhere near as close.
The exact SQL behind every number
WITH atm AS
(
SELECT
ticker,
days,
strike,
call_px,
put_px,
abs(days - 35) * 100000 + abs(call_px - put_px) AS rank_key
FROM
(
SELECT
underlying_symbol AS ticker,
toInt32(dateDiff('day', toDate(date), toDate(expiration_date))) AS days,
toFloat64(strike_price) AS strike,
anyIf(toFloat64(option_close), upper(toString(option_type)) LIKE 'C%') AS call_px,
anyIf(toFloat64(option_close), upper(toString(option_type)) LIKE 'P%') AS put_px
FROM global_markets.options_greeks
WHERE underlying_symbol IN ('AAPL', 'JPM', 'KO', 'MSFT', 'NVDA', 'SPY')
AND toDate(date) =
(
SELECT max(toDate(date))
FROM global_markets.options_greeks
WHERE toDate(date) < today()
AND toDate(date) >= today() - 400
)
AND dateDiff('day', toDate(date), toDate(expiration_date)) BETWEEN 20 AND 60
GROUP BY ticker, days, strike
HAVING call_px > 0 AND put_px > 0
)
)
SELECT
ticker,
round(argMin(strike, rank_key) / 10, 1) AS collateral_thousands,
round(argMin(strike / call_px, rank_key), 1) AS cash_per_call_dollar
FROM atm
GROUP BY ticker
ORDER BY cash_per_call_dollar DESCSelling that put cash secured in SPY reserves about 76.9 thousand dollars of buying power, which works out to 59.8 dollars of cash for every dollar a call buyer spends on the same directional view. At the far end of the panel NVDA ties up 20 dollars per call dollar. Margin lowers the reserve and adds a maintenance requirement that tracks the stock, and margin for selling naked options walks through the calculation.
A long call plus a short put equals the stock
Look again at the third line on the payoff grid. Combine the long call with the short put at the same strike and expiration and the payoff straightens out: -6363 dollars at $248 and 6037 dollars at $372, changing by the same amount for every dollar the share price adds. That straight line is 100 shares of stock, assembled from two options. The name for it is a synthetic long.
That is the cleanest way to see the choice. The two positions are the halves of one share position. Buying the call keeps the upside half and pays for a floor under the downside. Selling the put keeps the premium and takes the downside half on. Neither is the safe version of the other. They hand a trader different risks to be paid for, and both have a capped version, covered in credit spread vs debit spread.
FAQ
Is buying a call the same as selling a put?
No. Both gain when the shares rise and both carry positive delta, and the resemblance stops at the shape of the risk. A long call's loss ends at the premium paid. A short put's loss widens as the share price falls, all the way to a zero price.
What is the maximum loss on a short put?
The strike price minus the credit received, multiplied by the 100 shares in a contract, and it lands if the shares finish at zero. As a hypothetical: a $50 strike put sold for $2 carries a worst case of $4,800 per contract against a best case of the $200 credit.
Does selling a put tie up more capital than buying a call?
Ordinarily yes, by a wide margin. A cash secured put reserves the entire strike value for the life of the trade, while a call buyer parts with the premium alone. The collateral panel above measures that gap across several household names.
What happens to a long call and a short put when implied volatility drops?
With the share price unchanged, a drop in implied volatility takes value out of the long call and adds value to the short put. The long call holds positive vega and the short put negative vega, so one repricing runs through the two accounts in opposite directions.
Can a short put be assigned before expiration?
Yes. US listed equity options are American style, so the holder may exercise on any business day up to expiration. The seller then buys 100 shares per contract at the strike. Early exercise concentrates in deep in the money contracts and around ex dividend dates.
How these panels were pinned
Every panel on this page reads a single close, the Aug 18, 2026 session, so the five tables sit on one consistent set of marks. At each expiration a panel keeps the listed strike where the call and the put are marked closest together, the parity reading of at the money, and it keeps only strikes carrying a two sided pair, a call and a put with closing prices above zero. The payoff grid and the two capital panels hold to an expiration about five weeks out; the greeks panel walks every expiration from one week to about four months. Greeks are per share, as the options feed reports them, and every dollar figure on the payoff grid applies the 100 share contract multiplier.
Every panel here carries the SQL that produced it. Open one, change the ticker to a name you follow, and the same comparison rebuilds on the Strasmore terminal.