How to Read Options Symbol for OSI Format

An options symbol na one string wey carry four facts: the root of the underlying, the expiration date, whether na call or put, and the strike price. Dem call the layout OSI, after Options Symbology Initiative wey US options industry adopt for 2010, and every order ticket plus data feed dey build on top am. Once you learn the four fields, you fit decode any listed US option symbol as you see am.

Which four fields dey inside option symbol?

Canonical OSI symbol get 21 characters, for fixed order:

• The root, six characters, aligned from the left. If the underlying root short pass six characters, dem pad the remaining space for the right.
• The expiration, six digits, for YYMMDD order. 260116 na January 16, 2026.
• The right, one character: C for call, P for put.
• The strike, eight digits, expressed for thousandths of a dollar without decimal point.

Most brokers and websites dey remove the padding and show the compact form. Some feeds dey put marker like O: for front of the string. Neither one change how you parse am. The last 15 characters always be the date, the right and the strike. So the root na anything wey dey before dem. The panel below split real contracts with this rule and put the parsed fields beside the expiration wey the contract record itself carry.

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 parse to root of SPY, date field of 260116, right of C and strike field of 00500000. When you divide am down, strike na $500. The contract own expiration record show Jan 16, 2026, and e match the six digits inside the string. The panel get 8 contracts: the same strikes listed as calls and puts. Na one character dey separate a call from the matching put. This na why you need check that character twice for order ticket. If these fields look familiar from your broker screen, how to read option chain explain the columns wey dey around dem.

How to read options symbol for command line

You no need libraries or network access to parse am. The fields get fixed width, and you measure dem from the right. For bash, substring expansion dey enough. Paste this for 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 before each negative offset dey required. If e no dey there, bash go read :- as default value expansion and print the wrong thing.

For list of symbols, awk fit do 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

Python3 version dey handle the padded 21-character form and the feed prefix inside the same function. E no use anything outside 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 dey run on normal Ubuntu image with nothing installed apart from awk and python3. Neither one connect to network, so output go remain the same today and five years from now.

Why strike of 00007500 mean $7.50?

Strike field get eight digits without decimal point, and its unit na one thousandth of a dollar. Divide am by 1,000 to get dollars. 00007500 na 7,500 thousandths, or $7.50. 07500000 na 7,500,000 thousandths, or $7,500. The two differ by three zeros hidden inside one long run of zeros. Na this be the most common way people misread the whole format. Fixed width keep every symbol the same length, while the thousandths unit leave room for strikes wey corporate action fit place on fractions of a cent.

One field must cover every listed strike, from low-priced share to four-digit index level. The panel below read the lowest and highest strike for several underlyings and print the eight digits exactly as dem 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

For the sessions wey dey shown, KO list strikes from $32.5 to $125, written as 00032500 and 00125000 inside the symbol. For the far end of the panel, SPY reach $1480, or 01480000, across 462 distinct strikes. Same eight digits and same divisor, no matter the price level.

Adjusted options: wetin number for end of root mean

Standard equity option deliver 100 shares. Corporate actions fit change this: split with ratio wey no be whole number, merger wey partly pay cash, spinoff, or special cash dividend above the threshold. OCC adjust the open contracts and give dem new root: the old root with digit added. Root ABC become ABC1 for first adjustment and ABC2 for second one. The layout no change, so your parser still dey work. But the deliverable behind the contract change, and the symbol no tell you about am.

Digit for the end also dey mark mini contracts, with 7. These ones cover 10 shares instead of 100. For either case, the number na signal say you need read the contract terms before you compare the strike with anything. Our note on how stock splits affect options explain the ratio math for both the strike and the deliverable.

Adjusted series rarely get new expirations added. Root like ABC1 go thin out as its listed dates expire, instead of receiving fresh dates. E fit disappear completely from a chain after the last one expires. The terms dey inside the OCC adjustment memo for that contract, not inside the string. The memo name the revised deliverable, any cash component, and the multiplier wey follow am. Until you read that memo, adjusted strike and standard strike on the same underlying na two different things wey happen to wear the same eight digits.

SPX, SPXW, and wetin W dey mark

Index options get their own roots, and S&P 500 complex na the one wey most people meet first. SPX and SPXW reference the same index and use the same 21-character layout. W no longer mean weekly listing, no matter wetin the name suggest. SPX na the AM settled root: the third Friday contract wey settlement value build from opening prints of the index components on expiration Friday. Trading dey end on the Thursday before. SPXW na the PM settled root. E cover every other date for the calendar, from Monday-to-Friday dailies to month-end contracts. Each one dey trade until close of its own expiration day.

The calendar split along the same line. One AM settled third Friday contract for each monthly cycle dey under SPX root. Every other forward date on the index belong to SPXW. For a full chain, na most of the expirations you go see. The string no mark all this by itself. The root na the hint, while contract specification na the authority. Two roots, one index, one screen, and settlement mechanics wey AM versus PM settled options explain in detail.

Wetin option symbol never tell you

The four fields identify a contract completely, but dem describe very little about am. In particular:

• The multiplier. Standard US equity option cover 100 shares, but no field for the string tell you this. Adjusted series and mini series differ, while index products set their own terms.
• The settlement style. Nothing for the symbol mark AM versus PM settlement, or cash settlement versus physical delivery. For index roots, the convention fit give hint, but only contract specification get final authority.
• The deliverable. After adjustment, the 100-share assumption no longer apply. The symbol look exactly the same apart from the digit.
• Time left. Date field give expiration date, not countdown. To turn am into days to expiry, you need do the calendar arithmetic yourself.
• Liquidity. Two symbols with identical structure fit have very different volume and open interest.

FAQ

How many characters option symbol get?

Twenty one for canonical OSI form: six for root, six for date, one for call or put flag, and eight for strike. Roots wey shorter than six characters get spaces added. Most screens remove that padding, so a three-letter root usually show as an 18-character string.

Wetin number after root for option symbol mean?

E mark contract wey terms no longer standard. Digit wey OCC append identify adjusted series after corporate action, while 7 mark mini contract wey cover 10 shares instead of 100. Date and strike fields still parse the same way.

Why strike get eight digits?

The field hold strike in thousandths of a dollar as fixed-width integer. This cover from one-tenth of a cent up to $99,999.999 without decimal point. Divide the eight digits by 1,000 to read dollars: 00007500 na $7.50.

SPXW na the same as SPX?

Dem reference the same index and use the same symbol layout. Settlement differ. SPX contracts settle to value wey build from Friday morning opening prints and stop trading the day before. SPXW contracts trade until close of their expiration day and settle to closing index level.

Option symbol show whether option na weekly or monthly?

For US equities, no. Weekly and monthly on the same underlying share one root. Dem differ only for the six date digits. Third Friday convention na wetin make a date look monthly, while index complexes use separate roots instead.

Every panel for this page carry the exact SQL wey produce am under an expander. So you fit see how each field come out of the string. If you want break down a symbol wey you dey look at now, ask for am in plain English on the Strasmore terminal.