Skip to content
All library documents

Option Greeks Data: Sensitivities, Implied Volatility, and Chain Filtering

Article NautilusTrader

Summary

This reference describes a data record for venue-provided option sensitivities and implied volatility associated with one option instrument. It includes delta, gamma, vega, theta, and rho, along with optional mark, bid, and ask implied volatility, underlying price, and open interest. Instrument identification and event and initialization timestamps are also part of the record, while a convention field specifies the numeraire basis for the values.

The record can be stored, replayed, and queried as a native data type. In the Rust interface it exposes the core Greek values directly, while the Python constructor accepts the sensitivities as separate arguments. Option chain subscriptions can use the underlying price and delta to select at-the-money or delta-based strike windows. These are data-model and subscription details; the document does not explain how Greeks are calculated or compare venue values with locally computed estimates, so interpretation depends on the supplied convention and source.

Key ideas

  • The record associates a set of option Greeks and volatility fields with a specific instrument.
  • The main sensitivities are delta, gamma, vega, theta, and rho.
  • Implied volatility quotes, underlying price, and open interest are optional fields.
  • The convention field identifies the numeraire basis for reported values.
  • Underlying price and delta can help resolve at-the-money and delta-based option chain windows.

Tags

OptionsDerivatives pricingVolatilityMarket microstructure
Full text
# OptionGreeks


# OptionGreeks

`OptionGreeks` represents venue-provided option sensitivities and implied volatility for one option
instrument. As a native `Data` enum variant, it can be recorded, replayed, and queried through the
catalog.

## Fields

| Field              | Rust type           | Python type        | Required/default | Notes                                      |
| ------------------ | ------------------- | ------------------ | ---------------- | ------------------------------------------ |
| `instrument_id`    | `InstrumentId`      | `InstrumentId`     | Required         | Option instrument for the Greeks.          |
| `convention`       | `GreeksConvention`  | `GreeksConvention` | Default          | Numeraire convention for the values.       |
| `greeks`           | `OptionGreekValues` | Separate floats    | Required         | Delta, gamma, vega, theta, and rho.        |
| `mark_iv`          | `Option<f64>`       | `float \| None`    | `None`           | Mark implied volatility.                   |
| `bid_iv`           | `Option<f64>`       | `float \| None`    | `None`           | Bid implied volatility.                    |
| `ask_iv`           | `Option<f64>`       | `float \| None`    | `None`           | Ask implied volatility.                    |
| `underlying_price` | `Option<f64>`       | `float \| None`    | `None`           | Underlying price used for the calculation. |
| `open_interest`    | `Option<f64>`       | `float \| None`    | `None`           | Open interest when published.              |
| `ts_event`         | `UnixNanos`         | `int`              | Required         | Event timestamp in nanoseconds.            |
| `ts_init`          | `UnixNanos`         | `int`              | Required         | Initialization timestamp in nanoseconds.   |

## Behavior

- `OptionGreeks` dereferences to its core `OptionGreekValues` on the Rust surface.
- The Python constructor accepts `delta`, `gamma`, `vega`, `theta`, and optional `rho`
  as separate float arguments.
- Option chain subscriptions use `underlying_price` and deltas to resolve ATM and
  delta-based strike windows.

## Example

```rust tab="Rust"
use nautilus_core::UnixNanos;
use nautilus_model::{
    data::{OptionGreekValues, OptionGreeks},
    enums::GreeksConvention,
    identifiers::InstrumentId,
};

let greeks = OptionGreeks {
    instrument_id: InstrumentId::from("BTC-20240628-65000-C.DERIBIT"),
    convention: GreeksConvention::PriceAdjusted,
    greeks: OptionGreekValues {
        delta: 0.51,
        gamma: 0.0002,
        vega: 12.5,
        theta: -3.2,
        rho: 0.1,
    },
    mark_iv: Some(0.55),
    bid_iv: Some(0.54),
    ask_iv: Some(0.56),
    underlying_price: Some(65_000.0),
    open_interest: Some(120.0),
    ts_event: UnixNanos::from(1_000_000_000),
    ts_init: UnixNanos::from(1_000_000_100),
};
```

```python tab="Python"
from nautilus_trader.model import InstrumentId
from nautilus_trader.model import OptionGreeks

greeks = OptionGreeks(
    instrument_id=InstrumentId.from_str("BTC-20240628-65000-C.DERIBIT"),
    delta=0.51,
    gamma=0.0002,
    vega=12.5,
    theta=-3.2,
    rho=0.1,
    mark_iv=0.55,
    bid_iv=0.54,
    ask_iv=0.56,
    underlying_price=65_000.0,
    open_interest=120.0,
    ts_event=1_000_000_000,
    ts_init=1_000_000_100,
)
```

## Related guides

- [Greeks](../greeks.md) covers venue-provided and locally computed Greeks.
- [Options](../options.md#optiongreeks-data-type) covers option chain subscriptions.
- [Python API reference](/docs/python-api-latest/model/data.html) lists Python members.

Shown in full with attribution under the source's licence. Licence: LGPL-3.0

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