Listed Option Contracts: Terms, Trading Increments, and Lifecycle Fields
Article NautilusTrader
Summary
This reference explains the fields used to describe a listed put or call on a non-crypto underlying. It covers contract identity, underlying asset, option type, strike, activation and expiration times, premium currency, price precision, minimum price increment, multiplier, and lot size. These terms help traders interpret instrument metadata and distinguish contract sizing rules from price quoting rules.
The document says listed options trade in whole contracts, with a size increment of one, and that option type and strike define the payoff shape. It provides equity-option construction examples in Rust and Python and names market-data and brokerage adapters that use this instrument model. It also distinguishes crypto options, which use a separate contract type. This is a data-model reference rather than a guide to valuation, Greeks, strategy selection, or execution. It does not provide market examples, performance evidence, or guidance on how contract terms vary across venues, so users still need to check exchange specifications for a particular instrument.
Key ideas
- A listed option contract record includes its underlying, put-or-call type, strike, activation time, and expiration time.
- Options trade in whole contracts, with a size increment of one.
- The multiplier and lot size describe contract quantity conventions, while price precision and increment describe valid prices.
- The reference separates non-crypto listed options from crypto option contracts.
Tags
Full text
# Option Contract
# Option Contract
`OptionContract` represents a listed put or call option on a non-crypto underlying. It
defines the option kind, strike price, activation time, expiration time, currency,
multiplier, and lot size.
Examples include equity options, index options, and futures options.
## Fields
| Field | Rust type | Python type | Required/default | Notes |
| ----------------- | ------------------ | ------------------ | ---------------- | ---------------------------------------- |
| `instrument_id` | `InstrumentId` | `InstrumentId` | Required | Stored as `id` in Rust. |
| `raw_symbol` | `Symbol` | `Symbol` | Required | Native venue symbol. |
| `asset_class` | `AssetClass` | `AssetClass` | Required | Asset class of the underlying. |
| `exchange` | `Option<Ustr>` | `str \| None` | `None` | Exchange MIC or venue code when known. |
| `underlying` | `Ustr` | `str` | Required | Underlying asset, future, or index. |
| `option_kind` | `OptionKind` | `OptionKind` | Required | Put or call. |
| `strike_price` | `Price` | `Price` | Required | Option strike price. |
| `activation_ns` | `UnixNanos` | `int` | Required | Contract activation timestamp. |
| `expiration_ns` | `UnixNanos` | `int` | Required | Contract expiration timestamp. |
| `currency` | `Currency` | `Currency` | Required | Premium quote and settlement currency. |
| `price_precision` | `u8` | `int` | Required | Decimal places allowed for prices. |
| `price_increment` | `Price` | `Price` | Required | Smallest valid price step. |
| `size_precision` | `u8` | `int` | Fixed `0` | Options trade in whole contracts. |
| `size_increment` | `Quantity` | `Quantity` | Fixed `1` | Minimum contract size step. |
| `multiplier` | `Quantity` | `Quantity` | Required | Contract multiplier. |
| `lot_size` | `Quantity` | `Quantity` | Required | Rounded lot or contract lot size. |
| `margin_init` | `Option<Decimal>` | `Decimal \| None` | `0` | Initial margin rate. |
| `margin_maint` | `Option<Decimal>` | `Decimal \| None` | `0` | Maintenance margin rate. |
| `max_quantity` | `Option<Quantity>` | `Quantity \| None` | `None` | Maximum order quantity. |
| `min_quantity` | `Option<Quantity>` | `Quantity \| None` | `1` | Minimum order quantity. |
| `max_price` | `Option<Price>` | `Price \| None` | `None` | Maximum valid quote or order price. |
| `min_price` | `Option<Price>` | `Price \| None` | `None` | Minimum valid quote or order price. |
| `tick_scheme` | `Option<Ustr>` | `str \| None` | `None` | Registered variable tick scheme name. |
| `info` | `Option<Params>` | `dict \| None` | `None` | Adapter metadata. |
| `ts_event` | `UnixNanos` | `int` | Required | Event timestamp in nanoseconds. |
| `ts_init` | `UnixNanos` | `int` | Required | Initialization timestamp in nanoseconds. |
*Note: Python constructors use `instrument_id`; Rust stores the same value as `id`.*
## Behavior
- `OptionContract` has instrument class `Option`.
- It trades in whole contracts with size precision `0` and size increment `1`.
- The option kind and strike price define the payoff shape.
- Use `CryptoOption` for options where the underlying and settlement are crypto currencies.
## Example
```rust tab="Rust"
use jiff::Timestamp;
use nautilus_core::UnixNanos;
use nautilus_model::{
enums::{AssetClass, OptionKind},
identifiers::{InstrumentId, Symbol},
instruments::OptionContract,
types::{Currency, Price, Quantity},
};
use ustr::Ustr;
let activation: Timestamp = "2021-09-17T00:00:00Z".parse().unwrap();
let expiration: Timestamp = "2021-12-17T00:00:00Z".parse().unwrap();
let aapl_call = OptionContract::builder()
.instrument_id(InstrumentId::from("AAPL211217C00150000.OPRA"))
.raw_symbol(Symbol::from("AAPL211217C00150000"))
.asset_class(AssetClass::Equity)
.exchange(Ustr::from("GMNI"))
.underlying(Ustr::from("AAPL"))
.option_kind(OptionKind::Call)
.strike_price(Price::from("150.00"))
.currency(Currency::from("USD"))
.activation_ns(UnixNanos::from(activation))
.expiration_ns(UnixNanos::from(expiration))
.price_precision(2)
.price_increment(Price::from("0.01"))
.multiplier(Quantity::from("100"))
.lot_size(Quantity::from("1"))
.ts_event(UnixNanos::default())
.ts_init(UnixNanos::default())
.build()
.unwrap();
```
```python tab="Python"
import pandas as pd
from nautilus_trader.model import AssetClass
from nautilus_trader.model import Currency
from nautilus_trader.model import InstrumentId
from nautilus_trader.model import OptionContract
from nautilus_trader.model import OptionKind
from nautilus_trader.model import Price
from nautilus_trader.model import Quantity
from nautilus_trader.model import Symbol
aapl_call = OptionContract(
instrument_id=InstrumentId.from_str("AAPL211217C00150000.OPRA"),
raw_symbol=Symbol("AAPL211217C00150000"),
asset_class=AssetClass.EQUITY,
underlying="AAPL",
option_kind=OptionKind.CALL,
strike_price=Price.from_str("150.00"),
currency=Currency.from_str("USD"),
activation_ns=pd.Timestamp("2021-09-17", tz="UTC").value,
expiration_ns=pd.Timestamp("2021-12-17", tz="UTC").value,
price_precision=2,
price_increment=Price.from_str("0.01"),
multiplier=Quantity.from_int(100),
lot_size=Quantity.from_int(1),
ts_event=0,
ts_init=0,
exchange="GMNI",
)
```
## Adapters
Representative adapters that create or consume `OptionContract` instruments include:
- [Databento](../../integrations/databento.md) for listed options data.
- [Interactive Brokers](../../integrations/interactive_brokers.md) for listed option contracts.
## Related guides
- [Options](../options.md) covers option data, Greeks, and chain subscriptions.
- [Crypto Option](crypto_option.md) covers crypto option contracts.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.