Estimating Binary FX Option Volatility from the Market Smile

# How to derive appropriate volatility for a binary option (with strike/term) from market data?


# How to derive appropriate volatility for a binary option (with strike/term) from market data?












I am valuing a binary FX option (european) with a defined strike and term (2Y). I'm using a closed form solution based on Black-Scholes framework. How can I derive the appropriate volatility to use from the market data I have?

Market Data (all quoted in implied volatility):

```
ATM 
25D Risk Reversal 
25D Butterfly 
10D Risk Reversal
```

## Answer by quant_dev (score 3)

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

Binary options can be replicated (in theory) by trading long and short call options with very close strikes. Take the Black-Scholes formula and differentiate it over the strike. You will need to know the slope of the implied volatility skew around the strike of the binary option. This you can do by fitting a parametric formula (I don't know exactly what is used in FX, also SABR?) to your market data. If your option's strike is not too far away from ATM, you should get a reasonable number.

Disclaimer: I don't specialise in FX.

## Answer by user59 (score 2)

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

It might be easier to use the Black-Scholes formula for binary options:

http://en.wikipedia.org/wiki/Binary_option#Black-Scholes_Valuation

then add the distributions for each leg:

Heuristics for calculating theoretical probabilities of being ITM at time T for listed options

and then use numerical methods to calculate what volatility makes the legs match the quotes prices.

## Answer by AKdemy (score 1)

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

In the simplest case, you can just assume a flat vol Black Scholes world. In this case, using the usual BS notation, the fair price of the cash or nothing option is e^(−rt)*N(d2) which is the discounted probability of the option expiring in the money.

Demonstrating this in Julia, you can define this as follows (call price will be needed later).

```
using Distributions
function BSM(S,K,t,rf,d,σ, cp_flag)
    d1 = ( log(S/K) + (rf - d + 1/2*σ^2)*t ) / (σ*sqrt(t))
    d2 = d1 - σ*sqrt(t)
    value  = cp_flag*exp(-d*t)S*N(cp_flag*d1) - exp(-rf*t)*cp_flag*K*N(cp_flag*d2)
  return value, exp(-r*t)*N(cp_flag*d2)
end
```

Looking at an example from Bloomberg,

we can compute the following result

```
# inputs 
s,k , t, σ, r, d  = 19280.78, 19280.78, 1, 0.2471, -0.00006, 0.02061
#result 
res = BSM(s,k,t,log(1+r*t)/t,log(1+d*t)/t,σ, 1)
println("Digital Value per unit = $(round(res[2],digits = 5))")
```

Bloomberg does not seem to use a call spread in OVME which is why it is so close. Bloomberg does use a call spread in OVML (FX) though. If you were to do this yourself, things get a bit more involved. For example, setting strikes at 𝐾± = 𝐾 ±1/2𝑑𝐾.

The gif shows this with unrealistic spreads and shifts to make the distinction clear. The actual values however are computed accurately and would match OVML. You can read some details here.

We need to define a few more things to set this up:

- compute the spread (frequently 1% is used, but ideally it is expiry and vol dependent)

```
function spread(K,shift)
        lower_K = K*(1-shift/2)
        upper_K = K*(1+shift/2)
        spread  = upper_K-lower_K
        return lower_K, upper_K, spread
    end
spr = spread(k,0.01)
val = ("Lower","Upper","Spread")
k = Dict(zip(val,spr))
```

- Compute the notional adjustment needed to get the desired payoff (The spread * Notional equals the sum of payoffs in the spread scenario - this needs to be adjust to get the desired notional).

```
    function notional(desiredPayoff,spread)
        scale = desiredPayoff/(spread*desiredPayoff)
        return scale*desiredPayoff
    end
```

- Fetch the IV for the two strikes (for simplicity I just assume 3 different scenarios: flat, higher vol for lower strike (OTM Put Skew), higher upper strike (OTM Call Skew).

```
σ = Dict("Lower" =>  [0.2471,0.2473,0.2470], "Upper" =>  [0.2471,0.2470,0.2473] )
```

- compute value (in percent of underlying):

```
scenario = ["Flat", "OTM Put Skew", "OTM Call Skew"]
res = ["Digital Value per unit ($(scenario[i])) = $((BSM(s,k["Lower"],t, log(1+r*t)/t,log(1+d*t)/t,σ["Lower"][i],1)[1] - BSM(s,k["Upper"],t, log(1+r*t)/t,log(1+d*t)/t,σ["Upper"][i],1)[1])*notional(s,spr[3])/s)" for i in 1:1:3 ]
```