Early access is open. Free sample datasets are live now. Download a sample

Learn

OCC Option Symbols, Decoded

6 min read · Updated 19 November 2026 · By the marketdata.co data team

AAPL261218C00200000 looks like a serial number, but every character means something. It is the OCC option symbol, the standard way US listed options are identified, and once you can read it you can parse, build and join option data without a lookup table.

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 (root SPXW), 31 December 2026, strike 6,500. The root differs from the underlying SPX, which is why root_symbol and underlying_symbol are 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: symbol in OCC form, underlying_symbol, root_symbol, expiration_date, strike_price, option_type, exercise_style, contract_multiplier and an is_adjusted flag.

  • 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