What Is Put-Call Parity?
Put-call parity is the no-arbitrage relationship linking the prices of a European call option, a European put option, the underlying asset, and a risk-free bond - all sharing the same strike price and expiration date. If one side of the relationship is mispriced relative to the other, traders can lock in a risk-free profit.
The idea was first formalised by Hans Stoll in a 1969 paper, though the underlying logic follows directly from the law of one price: two portfolios that guarantee the same payoff at expiry must cost the same today. If they don't, someone will buy the cheap one, sell the expensive one, and pocket the difference. That pressure pushes prices back into line almost immediately.
Put-call parity doesn't tell you what a call or put should cost in absolute terms - that's the job of models like Black-Scholes. Instead, it tells you the relative relationship between call and put prices. If you know the call price, you can back out the put price, and vice versa. This makes it one of the most practically useful results in options theory, and it holds regardless of which pricing model you prefer.
In 2026, put-call parity remains the first thing traders check when screening for mispricing. It's the foundation on which synthetic positions, conversion trades, and reversal strategies are built.
The Put-Call Parity Formula
The put-call parity formula states that the price of a European call plus the present value of the strike price equals the price of a European put plus the current stock price. In symbols: C + PV(K) = P + S. Any deviation from this equation creates a risk-free arbitrage opportunity.
The standard form is:
$$C + K e^{-rT} = P + S$$
Where:
- C = price of the European call option
- P = price of the European put option
- K = strike price of both options
- S = current price of the underlying asset
- r = continuously compounded risk-free interest rate
- T = time to expiration (in years)
- e⁻ʳᵀ = the discount factor, giving the present value of £1 received at expiry
You can rearrange this to isolate whichever variable you need:
$$C = P + S - K e^{-rT}$$
$$P = C - S + K e^{-rT}$$
The term $Ke^{-rT}$ is simply the present value of the strike price. If you're working with simple (discrete) compounding rather than continuous compounding, replace this with $K / (1 + r)^T$. The logic is identical either way.
Note that put-call parity requires both options to be European-style (exercisable only at expiry), written on the same underlying, with the same strike and the same expiry date. It also assumes no dividends are paid before expiry - we'll address that adjustment later.
Deriving Put-Call Parity
The derivation rests on one principle: two portfolios with identical payoffs at expiry must have the same value today. If they didn't, you could buy the cheaper one and sell the dearer one, earning a guaranteed profit with zero risk.
Consider two portfolios constructed today:
Portfolio A: Fiduciary Call
- Buy one European call option with strike K (costs C)
- Buy a zero-coupon bond that pays K at expiry (costs $Ke^{-rT}$)
Portfolio B: Protective Put
- Buy one European put option with strike K (costs P)
- Buy one share of the underlying stock (costs S)
Now let's examine what each portfolio is worth at expiry, depending on where the stock price $S_T$ ends up.
Case 1: Stock finishes above the strike ($S_T > K$)
| Portfolio | Component values | Total |
|---|---|---|
| A (Fiduciary call) | Call pays $(S_T - K)$, bond pays $K$ | $S_T$ |
| B (Protective put) | Put expires worthless, stock is worth $S_T$ | $S_T$ |
Case 2: Stock finishes below the strike ($S_T < K$)
| Portfolio | Component values | Total |
|---|---|---|
| A (Fiduciary call) | Call expires worthless, bond pays $K$ | $K$ |
| B (Protective put) | Put pays $(K - S_T)$, stock is worth $S_T$ | $K$ |
Case 3: Stock finishes exactly at the strike ($S_T = K$)
Both portfolios are worth exactly $K$.
In every possible scenario, Portfolio A and Portfolio B produce the same payoff. Since they're identical at expiry, they must cost the same today. That gives us:
$$C + K e^{-rT} = P + S$$
This is put-call parity. No assumptions about the distribution of stock returns were needed - no normal distribution, no stochastic process, nothing about volatility. The result follows purely from the absence of arbitrage. That's what makes it so general and so reliable.
Worked Example with Real Numbers
A put-call parity example with concrete numbers makes the relationship tangible. Here we'll price a put option using a known call price, then verify the parity equation balances.
Suppose the following market data for a European option on shares of a UK-listed company:
| Parameter | Value |
|---|---|
| Current stock price (S) | £100 |
| Strike price (K) | £105 |
| Risk-free rate (r) | 4.5% per annum (continuous) |
| Time to expiry (T) | 6 months (0.5 years) |
| European call price (C) | £5.24 |
Step 1: Calculate the present value of the strike price.
$$PV(K) = K e^{-rT} = 105 \times e^{-0.045 \times 0.5} = 105 \times e^{-0.0225}$$
$$e^{-0.0225} \approx 0.97775$$
$$PV(K) = 105 \times 0.97775 = £102.66$$
Step 2: Apply the put-call parity formula to find the put price.
$$P = C + K e^{-rT} - S$$
$$P = 5.24 + 102.66 - 100 = £7.90$$
Step 3: Verify the parity holds.
Left side: $C + Ke^{-rT} = 5.24 + 102.66 = 107.90$
Right side: $P + S = 7.90 + 100 = 107.90$
Both sides match, confirming the relationship is satisfied.
What this tells you
If you observed the put trading at, say, £8.50 instead of £7.90, you'd know immediately that the put is overpriced relative to the call. The difference of £0.60 represents a potential arbitrage profit - enough to act on after accounting for transaction costs and bid-ask spreads. We'll look at exactly how to exploit that next.
Put-Call Parity and Arbitrage
When put-call parity is violated, traders can construct a position that locks in a risk-free profit. The two classic strategies for exploiting this are conversions (when the put is overpriced) and reversals (when the call is overpriced). In liquid markets, these violations rarely last more than a few seconds.
Detecting a Violation
Define the parity difference as:
$$\Delta = C + Ke^{-rT} - P - S$$
- If $\Delta = 0$: parity holds, no arbitrage
- If $\Delta > 0$: the left side is expensive (or the right side is cheap). Sell the call, buy the put, buy the stock, and borrow $Ke^{-rT}$
- If $\Delta < 0$: the right side is expensive (or the left side is cheap). Buy the call, sell the put, short the stock, and lend $Ke^{-rT}$
Example: Exploiting an Overpriced Put
Continuing our earlier example, suppose the put is trading at £8.50 instead of the fair value of £7.90.
$$\Delta = 5.24 + 102.66 - 8.50 - 100 = -0.60$$
Since $\Delta < 0$, Portfolio B (put + stock) is overpriced. The strategy is a reversal:
- Buy the call at £5.24
- Sell the put at £8.50
- Short the stock at £100
- Invest £102.66 in a risk-free bond (receiving £105 at expiry)
Net cash flow today: $-5.24 + 8.50 + 100 - 102.66 = +£0.60$
You receive £0.60 upfront. At expiry:
- If $S_T > 105$: exercise your call, pay £105, receive the stock, use it to close the short. Bond pays £105. Net: zero.
- If $S_T < 105$: the put is exercised against you, you buy the stock at £105, close the short. Bond pays £105. Net: zero.
- If $S_T = 105$: both options expire worthless, buy back the stock at £105 using bond proceeds. Net: zero.
In every scenario, the expiry payoff nets to zero. The £0.60 you collected at inception is pure profit. That's put-call parity arbitrage in action.
Why Violations Are Rare
In practice, market makers continuously monitor parity and quote prices that respect it. Algorithmic trading in 2026 means that any violation in liquid markets is exploited within milliseconds. Transaction costs, bid-ask spreads, and borrowing fees further erode potential profits, meaning only large violations are actionable. But the principle remains the foundation for relative-value options trading.
Put-Call Parity in Python
A Python implementation lets you systematically scan for parity violations across a large set of options. The function below calculates the theoretical put price from put-call parity and compares it against the observed market price.
import numpy as np def check_put_call_parity( call_price: float, put_price: float, stock_price: float, strike: float, rate: float, time_to_expiry: float, threshold: float = 0.05, ) -> dict: """ Check whether put-call parity holds for a European option pair. Parameters ---------- call_price : observed market price of the call put_price : observed market price of the put stock_price : current price of the underlying strike : shared strike price rate : continuously compounded risk-free rate time_to_expiry : years until expiry threshold : maximum acceptable deviation (in currency units) Returns ------- dict with theoretical prices, observed deviation, and arbitrage signal """ pv_strike = strike * np.exp(-rate * time_to_expiry) # Theoretical prices implied by parity implied_put = call_price + pv_strike - stock_price implied_call = put_price + stock_price - pv_strike # Deviation: positive means call side is expensive deviation = (call_price + pv_strike) - (put_price + stock_price) if abs(deviation) <= threshold: signal = "No arbitrage - parity holds within threshold" elif deviation > 0: signal = "Call side overpriced: sell call, buy put, buy stock, borrow PV(K)" else: signal = "Put side overpriced: buy call, sell put, short stock, lend PV(K)" return { "pv_strike": round(pv_strike, 4), "implied_put": round(implied_put, 4), "implied_call": round(implied_call, 4), "deviation": round(deviation, 4), "signal": signal, } # Example from the worked calculation above result = check_put_call_parity( call_price=5.24, put_price=8.50, stock_price=100, strike=105, rate=0.045, time_to_expiry=0.5, threshold=0.05, ) for key, value in result.items(): print(f"{key}: {value}")
Running this produces:
pv_strike: 102.6636
implied_put: 7.9036
implied_call: 5.8364
deviation: -0.5964
signal: Put side overpriced: buy call, sell put, short stock, lend PV(K)
The function confirms the put is overpriced by roughly £0.60, consistent with our manual calculation. You could extend this to loop through an entire options chain - pulling live data from a broker API - and flag any pair where the deviation exceeds your transaction cost estimate.
Scanning an Entire Options Chain
# Hypothetical options chain data for a single expiry options_chain = [ {"strike": 95, "call": 10.15, "put": 3.20}, {"strike": 100, "call": 6.80, "put": 5.10}, {"strike": 105, "call": 5.24, "put": 8.50}, {"strike": 110, "call": 2.95, "put": 11.40}, ] stock_price = 100 rate = 0.045 time_to_expiry = 0.5 print(f"{'Strike':<10}{'Deviation':<12}{'Signal'}") print("-" * 60) for opt in options_chain: result = check_put_call_parity( call_price=opt["call"], put_price=opt["put"], stock_price=stock_price, strike=opt["strike"], rate=rate, time_to_expiry=time_to_expiry, ) print(f"{opt['strike']:<10}{result['deviation']:<12}{result['signal']}")
This kind of systematic screening is standard practice at quantitative trading desks, where automation ensures that even fleeting violations are captured.
Put-Call Parity for American Options
For American options, put-call parity becomes an inequality rather than a strict equation. The possibility of early exercise means an American option can be worth more than its European equivalent, which breaks the exact relationship.
The bounds for American options are:
$$S - K \leq C_A - P_A \leq S - Ke^{-rT}$$
Where $C_A$ and $P_A$ are American call and put prices.
Why the exact equality fails
The derivation of put-call parity depends on both options being held until expiry so that the two portfolios produce identical payoffs. With American options, either side can be exercised early, meaning the payoffs at any given point before expiry are no longer guaranteed to match.
For American calls on non-dividend-paying stocks, early exercise is never optimal (you'd lose the time value and the interest on the strike). So the American call price equals the European call price: $C_A = C$.
American puts, however, are often exercised early. When a stock falls well below the strike, the intrinsic value of exercising now and investing the proceeds at the risk-free rate can exceed the time value of waiting. This early exercise premium means $P_A \geq P$, breaking the strict equality.
Practical impact
In practice, the deviation from European put-call parity for American options is small unless the put is deep in the money and interest rates are high. Most options traders in 2026 work with the European parity as a first approximation, then adjust for the early exercise premium when needed. For index options (like those on the FTSE 100 or S&P 500), which are typically European-style, put-call parity holds exactly.
Put-Call Parity with Dividends
When the underlying stock pays dividends before the option expires, the put-call parity formula requires an adjustment. You subtract the present value of expected dividends from the stock price, reflecting the fact that the option holder doesn't receive dividends.
The adjusted formula is:
$$C + Ke^{-rT} = P + S - PV(D)$$
Where $PV(D)$ is the present value of all dividends expected to be paid before the option's expiry date.
Rearranging for the put:
$$P = C + Ke^{-rT} - S + PV(D)$$
Worked example with dividends
Take the same setup as before, but now assume the stock pays a dividend of £2.00 in three months (0.25 years from now).
$$PV(D) = 2.00 \times e^{-0.045 \times 0.25} = 2.00 \times 0.98882 = £1.98$$
The adjusted put price becomes:
$$P = 5.24 + 102.66 - 100 + 1.98 = £9.88$$
Compare this with the no-dividend put price of £7.90. The dividend increases the put's fair value by £1.98, which makes intuitive sense: the stock is expected to drop by the dividend amount on the ex-date, making the put more valuable.
Continuous dividend yield
For indices or stocks with frequent dividends, it's often easier to model dividends as a continuous yield $q$:
$$C + Ke^{-rT} = P + Se^{-qT}$$
This is the form you'll typically see for index options. With a 2% continuous dividend yield and six months to expiry:
$$Se^{-qT} = 100 \times e^{-0.02 \times 0.5} = 100 \times 0.99005 = £99.01$$
The dividend adjustment reduces the effective stock price on the right side of the equation, reflecting dividends the stock holder receives but the call holder does not.
Why Put-Call Parity Matters
Put-call parity is the single most important constraint in options pricing. It enables traders to price options relative to one another, construct synthetic positions, and verify that market prices are internally consistent - all without needing a specific pricing model.
Pricing and model validation
Any options pricing model worth using must produce call and put prices that satisfy put-call parity. If your model spits out a call price and a put price for the same strike and expiry that don't satisfy the equation, something is wrong with the model, not the market. This makes parity a powerful diagnostic tool.
Synthetic positions
Put-call parity lets you build synthetic versions of any standard position:
- Synthetic long stock: buy call + sell put + invest $Ke^{-rT}$ in a risk-free bond
- Synthetic long call: buy stock + buy put - borrow $Ke^{-rT}$
- Synthetic long put: buy call + short stock + invest $Ke^{-rT}$
These synthetic positions are useful when a particular option is illiquid, unavailable, or mispriced. For example, if puts on a stock are thinly traded but calls are liquid, you can create a synthetic put using a call and stock position. This is standard practice at derivatives desks.
Understanding the Greeks
Because parity links calls and puts mechanically, the Greeks of one can be derived from the other. For example, a long call and a short put at the same strike have a combined delta of approximately 1.0 (equivalent to owning the stock). If you know a call's delta, the corresponding put's delta is simply delta minus 1. Strategies like butterfly spreads rely on this relationship when constructing positions from combinations of calls and puts.
Market microstructure
Market makers use parity to quote consistent two-sided markets in both calls and puts. Rather than pricing each option independently, they price one side (often the call) and derive the other from parity. This ensures their quotes don't inadvertently create arbitrage opportunities for other participants.
Frequently Asked Questions
What is put-call parity in simple terms?
Put-call parity is the rule that says a European call option plus cash equal to the present value of the strike price must cost the same as a European put option plus the underlying stock - provided both options have the same strike and expiry. If this relationship breaks, traders can make a guaranteed profit by exploiting the difference. It's not a pricing model; it's a consistency condition that any correctly functioning market must satisfy.
Does put-call parity work for American options?
Not exactly. For American options, put-call parity holds as an inequality rather than a strict equality. The right to exercise early - particularly relevant for puts - introduces an additional premium that can push the American put price above what European parity implies. For American calls on non-dividend-paying stocks, the equality still holds because early exercise isn't optimal. In practice, the European version serves as a close approximation, with adjustments for deep in-the-money puts where early exercise is likely.
Can you actually make money from put-call parity arbitrage?
In theory, yes - any violation of parity is a risk-free profit opportunity. In practice, pure parity arbitrage in liquid markets like FTSE 100 index options or S&P 500 options is extremely difficult for retail traders. Market makers and algorithmic systems monitor parity continuously and correct violations within milliseconds. Transaction costs, bid-ask spreads, and borrowing fees typically consume any small mispricing. However, parity violations do occasionally appear in less liquid markets, during periods of stress, or across related instruments where the connection is less obvious.
How is put-call parity related to Black-Scholes?
Put-call parity is more fundamental than Black-Scholes. The parity relationship holds under any no-arbitrage framework and doesn't require any assumptions about how stock prices move. Black-Scholes, by contrast, assumes geometric Brownian motion with constant volatility. However, Black-Scholes option prices always satisfy put-call parity - you can verify this by subtracting the Black-Scholes put formula from the call formula and simplifying. If a model's outputs violate parity, the model is broken.
What happens to put-call parity when interest rates change?
When interest rates rise, the present value of the strike price $Ke^{-rT}$ falls. From the parity equation $C + Ke^{-rT} = P + S$, this means that - all else equal - call prices increase and put prices decrease as rates rise. This is consistent with the intuition that higher rates increase the cost of carrying stock (favouring calls) and reduce the present value of the exercise payoff for puts. Rate sensitivity is captured by the Greek rho, and parity ensures the rho values of corresponding calls and puts are internally consistent.
Does put-call parity apply to options on futures?
Yes, but the formula is slightly different. For European options on futures, the stock price S is replaced by the discounted futures price $Fe^{-rT}$:
$$C + Ke^{-rT} = P + Fe^{-rT}$$
This simplifies to:
$$C - P = (F - K)e^{-rT}$$
The logic is identical: two portfolios with the same payoff at expiry must cost the same today. Options on futures are common for commodities, interest rate products, and index futures, and this adapted parity is the standard no-arbitrage check in those markets.
Want to go deeper on Put-Call Parity: What It Is, Formula & Examples 2026?
This article covers the essentials, but there's a lot more to learn. Inside Quantt, you'll find hands-on coding exercises, interactive quizzes, and structured lessons that take you from fundamentals to production-ready skills — across 50+ courses in technology, finance, and mathematics.
Free to get started · No credit card required