Details
The format
The OCC symbol (from the Options Clearing Corporation's symbology) has four parts:
| Part | Length | Example | Meaning |
|---|---|---|---|
| Root | up to 6 | AAPL |
Underlying or option root |
| Expiry | 6 | 261218 |
YYMMDD, here 18 December 2026 |
| Type | 1 | C |
C for call, P for put |
| Strike | 8 | 00200000 |
Strike × 1,000, zero-padded |
So AAPL261218C00200000 is the AAPL call expiring 18 December 2026 with a $200 strike. The strike field always has five digits before the implied decimal point and three after, so 00200000 is 200.000 and 00002500 is 2.500.
In the official 21-character form, the root is padded with spaces to six characters: AAPL 261218C00200000. Most APIs, ours included, drop the spaces. Our symbol field uses the compact form and every record also carries underlying_symbol, root_symbol, expiration_date, strike_price and option_type, so you rarely have to parse it yourself.
Worked examples
SPY261120P00590000: SPY put, expiring 20 November 2026, strike $590.SPXW261231C06500000: an SPX weekly-style call (rootSPXW), 31 December 2026, strike 6,500. The root differs from the underlyingSPX, which is whyroot_symbolandunderlying_symbolare separate fields.F270115C00012500: Ford call, 15 January 2027, strike $12.50.
These are examples of the format; check the contract list for what is actually listed.
Code
Parse and build in Python
"""Example: parse and build OCC option symbols."""
import re
from datetime import date
OCC = re.compile(r"^([A-Z0-9]{1,6})\s*(\d{2})(\d{2})(\d{2})([CP])(\d{8})$")
def parse_occ(sym):
m = OCC.match(sym)
if not m:
raise ValueError(f"bad OCC symbol: {sym}")
root, yy, mm, dd, cp, strike = m.groups()
return {
"root_symbol": root,
"expiration_date": date(2000 + int(yy), int(mm), int(dd)),
"option_type": "call" if cp == "C" else "put",
"strike_price": int(strike) / 1000,
}
def build_occ(root, expiry, option_type, strike):
cp = "C" if option_type == "call" else "P"
return f"{root}{expiry:%y%m%d}{cp}{round(strike * 1000):08d}"
print(parse_occ("AAPL261218C00200000"))
print(parse_occ("SPXW 261231C06500000"))
print(build_occ("F", date(2027, 1, 15), "call", 12.5))
The regex accepts both the padded and compact forms. build_occ uses round before converting the strike, because some strikes do not convert cleanly in floating point: 2.01 × 1000 gives 2009.9999999999998, which int() would truncate to the wrong strike.
Watch out
Common mistakes
Assuming the root equals the ticker. Index options use roots like SPXW, and after corporate actions an adjusted contract can carry a root such as AAPL1. Join on underlying_symbol, not on the first letters of the OCC symbol.
Losing the strike decimals. Treating the last eight digits as dollars gives strikes 1,000 times too large. Divide by 1,000.
Mixing padded and compact forms. AAPL 261218C00200000 and AAPL261218C00200000 are the same contract. Strip spaces before joining two datasets or you'll get zero matches.
Ignoring adjusted contracts. After a split or special dividend, existing contracts may get a new root and a different deliverable, often not 100 shares. Check is_adjusted and contract_multiplier before pricing them.
Details
Get the data
Every listed contract, active and expired. What you'll get:
symbolin OCC form,underlying_symbol,root_symbol,expiration_date,strike_price,option_type,exercise_style,contract_multiplierand anis_adjustedflag.
- Options contracts list API, planned for every plan including Free, in early access
- A free CSV of listed contracts, refreshed daily, is on the roadmap. Until then, a sample file is available on request.
FAQ
Frequently asked questions
What is an OCC option symbol?
It is the standard identifier for a US listed option: root, expiry as YYMMDD, C or P, and the strike times 1,000 as eight digits. For example, AAPL261218C00200000 is an AAPL $200 call expiring 18 December 2026.
How do I read the strike in an OCC symbol?
Take the last eight digits and divide by 1,000. 00200000 is $200 and 00012500 is $12.50.
Why do some OCC symbols have spaces?
The official format pads the root to six characters with spaces, making every symbol 21 characters long. Many APIs remove the spaces, so normalise both forms before comparing.
What does a number after the root mean, like AAPL1?
It usually marks an adjusted contract created after a corporate action such as a split or merger. These contracts can have a non-standard deliverable, so check the contract details before trading or pricing them.
Keep reading