How to Read an Options Symbol (OSI Format)

An options symbol is a single string that carries four facts: the root of the underlying, the expiration date, the call or put flag, and the strike price. The layout is called OSI, after the Options Symbology Initiative the US options industry adopted in 2010, and every order ticket and data feed is built on it. Learn the four fields once and you can decode any listed US option symbol on sight.

What are the four fields in an option symbol?

A canonical OSI symbol is 21 characters, in a fixed order:

• The root, six characters, left aligned and padded on the right with spaces when the underlying's root is shorter than six.
• The expiration, six digits, in YYMMDD order. 260116 is January 16, 2026.
• The right, one character: C for a call, P for a put.
• The strike, eight digits, carried in thousandths of a dollar with no decimal point.

Most brokers and websites strip the padding and show the compact form, and some feeds put a marker such as O: in front of the string. Neither changes the parse. The last 15 characters are always the date, the right and the strike, so the root is whatever sits in front of them. The panel below splits real contracts on that rule and puts the parsed fields next to the expiration the contract record itself carries.

SELECT
    contract,
    substring(contract, 1, length(contract) - 15)                  AS root,
    substring(contract, length(contract) - 14, 6)                  AS expiry_field,
    substring(contract, length(contract) - 8, 1)                   AS right_code,
    substring(contract, length(contract) - 7, 8)                   AS strike_field,
    toFloat64(substring(contract, length(contract) - 7, 8)) / 1000 AS strike_dollars,
    listed_expiration
FROM
(
    SELECT
        replaceRegexpOne(ticker, '^O:', '')               AS contract,
        formatDateTime(any(expiration_date), '%b %e, %Y') AS listed_expiration
    FROM global_markets.options_greeks
    WHERE underlying_symbol = 'SPY'
      AND expiration_date = '2026-01-16'
      AND toFloat64(strike_price) IN (500, 600, 650, 700)
      AND date >= '2025-12-01'
      AND date <  '2026-01-01'
    GROUP BY contract
)
ORDER BY strike_dollars ASC, right_code ASC

Row one parses to a root of SPY, a date field of 260116, a right of C and a strike field of 00500000, which divides down to a strike of $500. The contract's own expiration record reads Jan 16, 2026, matching the six digits inside the string. The panel holds 8 contracts: the same strikes listed as calls and as puts. One character separates a call from its matching put, which is why that character is the one to check twice on an order ticket. If the fields here look familiar from your broker screen, reading an option chain covers the columns that sit around them.

How to read an options symbol on the command line

The parse needs no libraries and no network access. The fields are fixed width measured from the right, so in bash a substring expansion is enough. Paste this into a terminal:

SYM=SPY260116C00650000
echo "root   ${SYM:0:$(( ${#SYM} - 15 ))}"
echo "expiry ${SYM: -15:6}"
echo "right  ${SYM: -9:1}"
echo "strike ${SYM: -8}"

The space in front of each negative offset is required. Without it, bash reads :- as a default value expansion and prints the wrong thing.

For a list of symbols, awk does the same arithmetic with one based positions:

awk '{
  n      = length($0)
  root   = substr($0, 1, n - 15)
  expiry = substr($0, n - 14, 6)
  right  = substr($0, n -  8, 1)
  strike = substr($0, n -  7, 8)
  printf "%-6s 20%s-%s-%s  %-4s $%.3f\n",
         root,
         substr(expiry, 1, 2), substr(expiry, 3, 2), substr(expiry, 5, 2),
         (right == "C" ? "call" : "put"),
         strike / 1000
}' <<'EOF'
SPY260116C00650000
SPY260116P00650000
SPXW260116C05500000
XYZ1260116C00007500
EOF

A python3 version handles the padded 21 character form and the feed prefix in the same function, using nothing outside the standard library:

from datetime import datetime

def parse_osi(symbol):
    s = symbol.strip()
    if s.startswith("O:"):
        s = s[2:]
    s = s.replace(" ", "")
    return {
        "root":   s[:-15],
        "expiry": datetime.strptime(s[-15:-9], "%y%m%d").date(),
        "right":  "call" if s[-9] == "C" else "put",
        "strike": int(s[-8:]) / 1000,
    }

samples = [
    "SPY   260116C00650000",
    "O:SPY260116P00650000",
    "SPXW  260116C05500000",
    "XYZ1  260116C00007500",
]

for sym in samples:
    f = parse_osi(sym)
    print("{:<6} {} {:<4} ${:,.3f}".format(f["root"], f["expiry"], f["right"], f["strike"]))

Both snippets run on a stock Ubuntu image with nothing installed beyond awk and python3, and neither one touches the network, so the output is identical today and in five years.

Why does a strike of 00007500 mean $7.50?

The strike field is eight digits with no decimal point, and its unit is one thousandth of a dollar. Divide by 1,000 to get dollars. 00007500 is 7,500 thousandths, or $7.50. 07500000 is 7,500,000 thousandths, or $7,500. The two differ by three zeros buried in a run of them, and that is the most common misread of the whole format. The fixed width keeps every symbol the same length, and the thousandths unit leaves room for strikes that land on fractions of a cent after a corporate action.

One field has to cover every listed strike, from a low priced share to a four digit index level. The panel below reads the lowest and highest strike for several underlyings and prints the eight digits exactly as they appear inside the symbol.

SELECT
    underlying,
    round(toFloat64(min(strike)), 2) AS lowest_strike,
    argMin(strike_field, strike)     AS lowest_strike_field,
    round(toFloat64(max(strike)), 2) AS highest_strike,
    argMax(strike_field, strike)     AS highest_strike_field,
    uniqExact(strike)                AS strike_count
FROM
(
    SELECT
        underlying_symbol AS underlying,
        strike_price      AS strike,
        substring(replaceRegexpOne(ticker, '^O:', ''),
                  length(replaceRegexpOne(ticker, '^O:', '')) - 7, 8) AS strike_field
    FROM global_markets.options_greeks
    WHERE underlying_symbol IN ('KO', 'NVDA', 'AAPL', 'SPY', 'SPX')
      AND date >= today() - 7
)
GROUP BY underlying
ORDER BY highest_strike ASC

Over the sessions in view, KO lists strikes from $32.5 to $125, written 00032500 and 00125000 inside the symbol. At the far end of the panel, SPY reaches $1480, or 01480000, spread across 462 distinct strikes. Same eight digits, same divisor, whatever the price level.

Adjusted options: what a number on the end of the root means

A standard equity option delivers 100 shares. Corporate actions can change that: a split in a ratio that is not whole, a merger paid partly in cash, a spinoff, or a special cash dividend above the threshold. The OCC adjusts the open contracts and issues them a new root, the old root with a digit appended. A root of ABC becomes ABC1 at the first adjustment and ABC2 at a second. The layout does not change, so your parser keeps working. The deliverable behind the contract does change, and the symbol says nothing about it.

A digit on the end is also how mini contracts are marked, with a 7, and those cover 10 shares rather than 100. Either way, the number is a flag that the contract terms need reading before the strike is worth comparing to anything. Our note on how stock splits affect options works through the ratio math on both the strike and the deliverable.

Adjusted series are rarely extended with new expirations. A root like ABC1 thins out as its listed dates run off rather than filling in with fresh ones, and it can disappear from a chain entirely once the last of them expires. The terms live in the OCC adjustment memo for that contract rather than in the string: the memo names the revised deliverable, the cash component if there is one, and the multiplier that travels with it. Until that memo has been read, an adjusted strike and a standard strike on the same underlying are two different things wearing the same eight digits.

SPX, SPXW, and what the W marks

Index options carry their own roots, and the S&P 500 complex is the one most people meet first. SPX and SPXW reference the same index and share the same 21 character layout. The W is no longer a statement about weekly listing, whatever the name suggests. SPX is the AM settled root: the third Friday contract whose settlement value is built from the opening prints of the index components on expiration Friday, with trading ending the Thursday before. SPXW is the PM settled root, covering everything else on the calendar, from Monday through Friday dailies to month end contracts, each trading until the close of its own expiration day.

The calendar splits along the same line. One AM settled third Friday contract per monthly cycle sits on the SPX root. Every other forward date on the index belongs to SPXW, and on a full chain that is most of the expirations in view. The string marks none of this on its own: the root is the hint, and the contract specification is the authority. Two roots, one index, one screen, and settlement mechanics that AM versus PM settled options takes apart in detail.

What an option symbol never tells you

The four fields identify a contract completely and describe it barely at all. In particular:

• The multiplier. A standard US equity option covers 100 shares, and no field in the string says so. Adjusted series and mini series differ, and index products set their own.
• The settlement style. Nothing in the symbol marks AM against PM settlement, or cash settlement against physical delivery. On index roots the convention hints at it, and only the contract specification is authoritative.
• The deliverable. After an adjustment the 100 share assumption is void, and the symbol looks exactly as it did apart from the digit.
• Time left. The date field gives an expiration, not a countdown. Turning it into days to expiry is arithmetic you do against the calendar yourself.
• Liquidity. Two symbols with identical structure can sit orders of magnitude apart in volume and open interest.

FAQ

How many characters is an option symbol?

Twenty one in the canonical OSI form: six for the root, six for the date, one for the call or put flag, and eight for the strike. Roots shorter than six characters are padded with spaces, and most screens drop that padding, so a three letter root usually displays as an 18 character string.

What does the number after the root in an option symbol mean?

It marks a contract whose terms are no longer standard. A digit appended by the OCC identifies an adjusted series following a corporate action, and a 7 marks a mini contract covering 10 shares instead of 100. The date and strike fields still parse the same way.

Why is the strike eight digits?

The field holds the strike in thousandths of a dollar as a fixed width integer, which spans a tenth of a cent up to $99,999.999 without ever needing a decimal point. Divide the eight digits by 1,000 to read dollars: 00007500 is $7.50.

Is SPXW the same as SPX?

They reference the same index and use the same symbol layout. Settlement differs. SPX contracts settle to a value built from Friday morning opening prints and stop trading the day before, and SPXW contracts trade through the close of their expiration day and settle to the closing index level.

Does an option symbol show whether an option is weekly or monthly?

For US equities, no. A weekly and a monthly on the same underlying share one root and differ only in the six date digits. The third Friday convention is what makes a date look monthly, and index complexes use separate roots instead.

Every panel on this page carries the exact SQL that produced it under an expander, so you can see how each field was cut out of the string. To decompose a symbol you are looking at right now, ask for it in plain English on the Strasmore terminal.