QuantLib European Option Pricing

Article Quant Q&A · Author: equanimity

Summary

The document presents a QuantLib setup for pricing a vanilla European call and obtaining delta, gamma, vega, and theta. The example specifies market inputs, dates, yield and volatility curves, an option payoff and exercise date, then connects them through an analytic Black–Scholes–Merton pricing engine. Its focus is the amount of setup required for a single calculation, rather than explaining the pricing formulas or sensitivities.

The responses describe QuantLib as a toolkit of reusable components: initial setup can feel verbose, while quote-based inputs allow subsequent recalculation for changing assumptions and sensitivity work. Writing formulas directly may not reduce code length. The example demonstrates a practical workflow but does not compare implementations, discuss model assumptions such as constant volatility, or evaluate numerical accuracy; the convenience depends on reusing the configured objects across inputs.

Key ideas

A QuantLib European option setup connects dates, market curves, payoff, exercise, and a pricing engine.
The analytic Black–Scholes–Merton engine returns both the option value and common Greeks.
QuantLib’s initial setup can be reused when market inputs change, supporting repeated calculations.
Hand-coding formulas does not necessarily make a one-off pricer shorter.

Tags

Options Derivatives pricing Volatility

Full text

# Easier way than using QuantLib to compute the price and Greeks of a vanilla European option?


# Easier way than using QuantLib to compute the price and Greeks of a vanilla European option?












I'm using the following to compute the price and Greeks a vanilla European option:

```
import QuantLib as ql

maturity_date = ql.Date(15, 1, 2016)
spot_price = 127.62
strike_price = 130
volatility = 0.20
dividend_rate =  0.0163
option_type = ql.Option.Call
        
risk_free_rate = 0.001
day_count = ql.Actual365Fixed()
calendar = ql.UnitedStates()
        
calculation_date = ql.Date(8, 5, 2015)
ql.Settings.instance().evaluationDate = calculation_date

payoff = ql.PlainVanillaPayoff(option_type, strike_price)
exercise = ql.EuropeanExercise(maturity_date)
european_option = ql.VanillaOption(payoff, exercise)

spot_handle = ql.QuoteHandle(
            ql.SimpleQuote(spot_price)
        )
flat_ts = ql.YieldTermStructureHandle(
            ql.FlatForward(calculation_date, 
                           risk_free_rate, 
                           day_count)
        )
dividend_yield = ql.YieldTermStructureHandle(
            ql.FlatForward(calculation_date, 
                           dividend_rate, 
                           day_count)
        )
flat_vol_ts = ql.BlackVolTermStructureHandle(
            ql.BlackConstantVol(calculation_date, 
                                calendar, 
                                volatility, 
                                day_count)
        )
bsm_process = ql.BlackScholesMertonProcess(spot_handle, 
                                                   dividend_yield, 
                                                   flat_ts, 
                                                   flat_vol_ts)

european_option.setPricingEngine(ql.AnalyticEuropeanEngine(bsm_process))

# price
bs_price = european_option.NPV()

price
6.749271812460607

# Greek sensitivities
delta = european_option.delta()
gamma = european_option.gamma()
vega = european_option.vega()
theta = european_option.theta()

delta
0.4582969846433817

gamma
0.018522331553816086

vega
41.655351781911605

theta
-5.131800499907545
```

This is a lengthy amount of code to price a vanilla option. Is there a more straightforward way?

Yes, I'm well aware that QuantLib is an extremely powerful engine and not necessarily built for simplicity, as mentioned very eloquently by @SmallChess in Why does it take so many lines of code to price even the simplest of options with QuantLib.

Are there any wrapper functions that I might be able to use to simplify things?

Thanks!

## Answer by David Duarte (score 3, accepted)

https://quant.stackexchange.com/a/69633

You should think of QuantLib as a set of very powerfull tools/parts which you can use to build your own pricers.

If you are going to price a single option, yes it takes a bit of boilerplate code to get the result.

But you can always reuse this code for different inputs, specially if you want to do sensitivity analysis. I think the way QuantLib stores inputs with quotes, enabling all consequent recomputation makes up for the initial boilerplate.

## Answer by user34031 (score 2)

https://quant.stackexchange.com/a/69631

You could simply code the formulas yourself, but this would not reduce the amount of code. I would say using quantlib is already very compact.

Shown in full with attribution under the source's licence. Licence: CC BY-SA 4.0 (Stack Exchange)

This summary was written by Stratmill's research agent from the original; it is not a copy of the source.

QuantLib’s Boilerplate and Reuse for European Option Pricing

Summary

Key ideas

Tags