Options trading API: symbols, chains, OPRA and assignment

Short answer: An options trading API is a broker interface that adds what a stock API lacks: OCC contract symbols, option chains with greeks, multi-leg orders, an account approval level, and exercise, assignment and expiry events. As read on 6 November 2026, Alpaca's greeks are calculated with Black-Scholes, while Tradier's come from ORATS and update hourly. Real-time US options data is licensed through OPRA, whose fee schedule counts automated trading as non-display use.

Written for developers adding US listed options to a stock integration. Facts come from official broker, exchange and regulator documents read on 6 November 2026; no account was available, so nothing was sent to a broker.

Options carry high risk, and a short option can lose far more than its premium. No broker is recommended or ranked, and there are no referral links. Rules depend on your country, and account types and API access vary. For readers in Turkey: the Capital Markets Board (SPK, also CMB) said on 23 February 2023 (opens in a new tab) that investors should carry out leveraged transactions only through institutions it has authorized (Law No. 6362 (opens in a new tab) Articles 99(4) and 109(2)). Article 99(4) lets the Board order online content removed or blocked when such transactions, or derivatives made subject to the same rules, are carried out from abroad for Turkish residents; the notice speaks of leveraged forex, not listed options, so ask a Turkish lawyer how it applies to you.

Options trading API: what it adds to a stock integration

An options integration needs seven pieces a stock integration lacks.

Contract size is the quiet trap: Alpaca's records carry a multiplier, 100 for standard contracts, and non-standard contracts can have several deliverables. Never assume 100 shares.

OCC option symbol format, and how brokers write it

The OCC symbol is 21 characters: a root of up to six characters padded with spaces, the expiration as yymmdd, C or P, and the strike times 1,000 in eight digits.

tastytrade's symbology page gives AAPL 220617P00150000 as the AAPL 17 June 2022 150 put and says the padding spaces are significant; such symbols must be URL-encoded in paths and query strings but sent raw in JSON. Alpaca's and Tradier's examples drop the padding, as in AAPL240119C00100000.

The root is not always the ticker. Cboe's circular on the Options Symbology Initiative, mandatory from 12 February 2010, allowed roots of up to five characters and gave corporate action symbols a number, such as IBM1; tastytrade's page allows six, so size parsers for six. Alpaca's chain reference gives AAPL1 as a root_symbol example: two contracts can share underlying, expiry, type and strike yet differ in deliverables, which the contracts endpoint lists with show_deliverables=true.

Options chain API: what the chain endpoints return

A chain call returns many contracts for one underlying, and each broker limits it differently, so plan for filters, paging and empty answers.

• Alpaca snapshots. GET /v1beta1/options/snapshots/{underlying_symbol} returns each contract's latest trade and quote, greeks and impliedVolatility. limit defaults to 100 and caps at 1,000 data points across all symbols; follow next_page_token.
• Alpaca contracts. GET /v2/options/contracts returns 100 rows a page by default (10,000 at most) and, without date filters, only active contracts expiring before the coming weekend, so one default call silently misses later expirations.
• Tradier. GET /v1/markets/options/chains requires symbol and expiration; an expiration the symbol does not list returns an empty response with no error, so fetch valid dates first. Greeks need greeks=true.

Treat an empty chain as an error (more in the Tradier API guide).

Option greeks API: who computes the numbers, and when

Greeks are model outputs rather than market data, so store their source and timestamp with every value.

Black-Scholes ignores early exercise, while Alpaca's contracts carry a style of american or european, so its values for American-style contracts can differ from models that price it. Do not mix sources, and never read a missing value as zero.

Options data API: OPRA licensing and fees

Real-time US listed options quotes come from OPRA, the Options Price Reporting Authority; its agreements and fees apply whether you or your vendor pays.

Alpaca offers opra, the consolidated best bid and offer, to subscribers, and a free indicative feed, a derivative of OPRA whose quotes are not actual OPRA quotes and whose trades are delayed 15 minutes. Its chain reference gives two different defaults for feed, so pass it explicitly.

Its non-display use covers automated or algorithmic trading engines run by OPRA vendors or professional subscribers with a direct agreement. The Category 1 fee does not apply in a calendar month when the recipient is one natural person with a single user ID, not a broker-dealer, averaging at most 390 listed-option orders a day (trading or calendar days is not stated). Data counts as delayed after at least 15 minutes. Licensing in general is in the stock market data API guide.

Multi-leg option orders and options approval levels

A spread goes in as one order with a net price and a list of legs, checked against the account's approval level.

Alpaca rejects two short calls in one order even though sending them separately is allowed; neither Alpaca nor Tradier states a leg maximum on the pages read.

Alpaca's options trading page, updated 16 September 2026, lists four approval levels:

Alpaca's paper accounts have options enabled by default, so paper tests prove nothing about the live level. In the US, FINRA Rule 2360(b)(16) requires written approval of the account, after due diligence on facts such as objectives, income, net worth and experience, before option orders are accepted. Read the account's approved and trading levels at start-up and handle rejections (see the Alpaca API Python guide).

Exercise, assignment and expiry events

Positions change after the close without an order from you, so reconcile from account activities, not just fills.

• Automatic exercise. Alpaca exercises contracts in the money by at least $0.01 at expiry unless told otherwise; do-not-exercise requests go through support, with no API described.
• Forced sale. Without buying power to exercise, Alpaca sells the position within 1 hour before expiry; no exact time is given.
• Exercise by API. POST /v2/positions/{symbol_or_contract_id}/exercise exercises the whole holding; requests between the close and midnight are rejected.
• Assignment. Not sent over the WebSocket: poll activities for OPASN, OPEXP and OPXRC (assignment, expiration, exercise; activities page updated 16 October 2026). In paper trading they appear only the following day.

Reconcile after the close and before the open, and expect stock from an assignment; a short American-style leg can be assigned early, leaving an option plus stock. See position reconciliation and paper trading API.

Options API in Python: a tested OCC symbol parser

Validate every symbol where it enters your system, and look a contract up by its terms only when exactly one row matches.

This ran offline with Python 3.11.3 on 6 November 2026, standard library only, on synthetic rows for a made-up XYZ.

import re
from datetime import date, datetime
from decimal import Context, Decimal, Inexact

OCC = re.compile(r"([A-Z0-9]{1,6}) *(\d{6})([CP])(\d{8})", re.ASCII)

def to_occ(root, expiry, right, strike, padded=True):
    if isinstance(strike, float):
        raise TypeError("strike must be str or Decimal, not float")
    try:  # no silent rounding
        milli = Decimal(strike).scaleb(3, Context(traps=[Inexact]))
    except ArithmeticError:
        raise ValueError(f"bad strike {repr(strike)}") from None
    if not milli.is_finite() or not 0 < milli < 10**8 or milli % 1:
        raise ValueError(f"strike not encodable: {repr(strike)}")
    if not re.fullmatch(r"[A-Z0-9]{1,6}", root) or right not in ("C", "P"):
        raise ValueError(f"bad root or right: {repr(root)} {repr(right)}")
    head = root.ljust(6) if padded else root
    return f"{head}{expiry:%y%m%d}{right}{int(milli):08d}"

def parse_occ(symbol):  # padded or compact form
    m = OCC.fullmatch(symbol)
    if not m or len(symbol) > 21 or (" " in symbol and len(symbol) < 21):
        raise ValueError(f"not an OCC symbol: {repr(symbol)}")
    root, ymd, right, digits = m.groups()
    expiry = datetime.strptime(ymd, "%y%m%d").date()
    strike = Decimal(digits) / 1000
    to_occ(root, expiry, right, strike)  # rejects a zero strike
    return root, expiry, right, strike

def find_one(rows, expiry, kind, strike, root=None):  # never guess
    hits = [r for r in rows if r.get("expiration_date") == expiry
            and r.get("type") == kind and root in (None, r.get("root_symbol"))
            and Decimal(str(r.get("strike_price"))) == Decimal(strike)]
    if len(hits) == 1:
        parse_occ(hits[0].get("symbol") or "")  # rejects an empty symbol
        return hits[0]["symbol"]
    raise LookupError(f"{len(hits)} matches: {[r.get('symbol') for r in hits]}")

for s in ["SPXW  220520C04025000", "AAPL240119C00100000"]:
    print(*parse_occ(s))
d = date(2026, 12, 18)
tests = [lambda: parse_occ("AAPL 240119C00100000"),
         lambda: parse_occ("AAPL  261131C00100000"),
         lambda: to_occ("XYZ", d, "C", 190.1),
         lambda: to_occ("XYZ", d, "C", "1e400"),
         lambda: to_occ("XYZ", d, "C", "1e-400"),
         lambda: to_occ("XYZ", d, "C", "50.0000000000000000000000000001")]
for test in tests:
    try:
        test()
    except (ValueError, TypeError) as e:
        print(type(e).__name__, "-", e)

rows = [{"symbol": s, "root_symbol": s[:-15], "expiration_date": "2026-12-18",
         "type": "call", "strike_price": "50"}  # synthetic, Alpaca field names
        for s in ("XYZ261218C00050000", "XYZ1261218C00050000")]
for args in [("call", "50"), ("call", "50", "XYZ"), ("put", "50")]:
    try:
        print(find_one(rows, "2026-12-18", *args))
    except LookupError as e:
        print("LookupError -", e)

Output:

SPXW 2022-05-20 C 4025
AAPL 2024-01-19 C 100
ValueError - not an OCC symbol: 'AAPL 240119C00100000'
ValueError - day is out of range for month
TypeError - strike must be str or Decimal, not float
ValueError - strike not encodable: '1e400'
ValueError - strike not encodable: '1e-400'
ValueError - bad strike '50.0000000000000000000000000001'
LookupError - 2 matches: ['XYZ261218C00050000', 'XYZ1261218C00050000']
XYZ261218C00050000
LookupError - 0 matches: []

The checks catch a single space that shifts every field, 31 November, a float strike (190.1 is stored as 190.0999...), "1e400" and "1e-400", which overflow eight digits or vanish at three decimals, and a 30-digit strike that plain Decimal multiplication would round to 50. The lookup found XYZ and the adjusted XYZ1 and refused to pick. For integration work in general, see Fincode's broker API integration page; naming Alpaca, Tradier or tastytrade here does not mean Fincode integrates them or has built on them.

Frequently asked questions

Which brokers offer an options trading API?

Alpaca, Tradier and tastytrade each document option symbols and multi-leg orders, as read on 6 November 2026; this is neither a ranking nor a complete list.

Is there a free options data API?

Alpaca's indicative feed is free, but its quotes are not actual OPRA quotes and its trades are delayed 15 minutes; real-time OPRA data is licensed.

How do I parse an OCC option symbol in Python?

Read the last 15 characters as yymmdd, C or P, and an eight-digit strike divided by 1,000; the rest, minus padding spaces, is the root. Keep the strike as a Decimal.

Can I trade options through an API without options approval?

No. Orders are checked against the account's options level, and in the US, FINRA Rule 2360 requires written account approval before option orders are accepted.

Sources

• tastytrade Developer Docs: Instruments and Symbology (OCC option format) (opens in a new tab)
• tastytrade Developer Docs: Multi-leg spreads (4 legs, price-effect, dry run) (opens in a new tab)
• Cboe Informational Circular IC10-48: OSI, Options Symbology Initiative (9 February 2010) (opens in a new tab)
• Alpaca Docs: Options Trading (levels, exercise, assignment; updated 16 September 2026) (opens in a new tab)
• Alpaca Docs: Options Level 3 Trading (multi-leg orders) (opens in a new tab)
• Alpaca API reference: Option chain snapshots (filters, greeks, feed) (opens in a new tab)
• Alpaca API reference: Get option contracts (multiplier, deliverables, default dates) (opens in a new tab)
• Alpaca Docs: Historical option data (indicative and OPRA feeds) (opens in a new tab)
• Alpaca Docs: Account activities (OPASN, OPEXP, OPXRC; updated 16 October 2026) (opens in a new tab)
• Tradier Docs: Get Options Chains (required expiration, greeks parameter) (opens in a new tab)
• Tradier Docs: Market Data (realtime and delayed, greeks from ORATS hourly) (opens in a new tab)
• Tradier Docs: Place Order (option, multileg and combo classes, preview) (opens in a new tab)
• OPRA: Fee Schedule (professional, nonprofessional and non-display fees) (opens in a new tab)
• FINRA Rule 2360: Options (account approval and disclosure document) (opens in a new tab)
• SPK (Capital Markets Board): Notice on unauthorized leveraged transactions, 23 February 2023 (Turkish) (opens in a new tab)

This guide is general information about software and markets, not investment, legal or tax advice. Automated trading can lose money, past or backtested performance does not guarantee future results, and the rules that apply depend on your jurisdiction and your exchange's terms. Sources, checks and corrections: see the editorial policy.