Why Your Market Data Vendor Returns Nothing for Gold Options

The one root that worked was the S&P 500. No error, no rejected subscription, no warning in the logs. Just an empty array where a chain should be.

Parent Symbology

Most institutional market-data feeds let you subscribe by parent rather than by individual instrument. Instead of enumerating every strike and expiry, you ask for the parent and receive all its children:

GC.FUT    # all gold futures contracts
GC.OPT    # all gold options... right?

That was the assumption: {ROOT}.FUT for the outright, {ROOT}.OPT for the options. It works perfectly for equity index, which is where we started.

GC.OPT returns nothing at all.

The Product Code Is Not the Underlying

CME states it plainly in their own documentation: the product code identifies the product upon which the derivative instrument is based, and may be different for the same underlying asset for futures and options instruments.

Gold futures are product GC. Gold options are product OG. They are different products, and parent symbology is keyed on the product code, not the underlying asset. So GC.OPT asks for "options whose product code is GC", and there are none.

Once you know this, the pattern is everywhere:

There is no derivable rule. ZN becomes OZN by prefixing an O. CL becomes LO, which is not a prefix of anything. You cannot compute these; you have to look them up.

The Clue That Was There All Along

The genuinely annoying part is that our own codebase already documented this behaviour, in a comment written months earlier for a different reason:

The standard {ROOT}.OPT parent (e.g. ES.OPT) carries ONLY the quarterly/serial options - verified: ES.OPT returns no daily/weekly expiries. The 0DTE-relevant daily/weekly/EOM series are SEPARATE CME products with their OWN product codes.

The equity-index weeklies had exactly the same problem. ES.OPT gives you the quarterlies; the Friday weeklies are product EW, the Monday dailies E1A, and so on. Someone had already discovered that options products have their own codes, built a mapping table for the weeklies, and moved on.

Nobody generalised it. When we added gold we reached for GC.OPT because that is what the pattern looked like, and the existing evidence sat in a comment about a different asset class.

The lesson is not "read your own comments". It is that a special case documented as a special case will stay special. Had the weekly mapping been named option product code mapping rather than weekly families, the generalisation would have been obvious.

The Exception That Proves the Rule

Not every product does this. Silver options resolve under SI.OPT. New Zealand dollar options resolve under 6N.OPT.

We discovered that by guessing wrong. We assumed silver would mirror gold and mapped SO -> SI. SO.OPT failed to resolve - dropped harmlessly by the gateway - while silver's chain populated anyway with 4,781 contracts, because its options genuinely do carry the futures root.

So the rule is not "cross-asset options have their own code". It is "some do, some don't, and you have to check each one".

Subscribe and Observe

Once we understood the failure mode, the safe way to discover codes became obvious. An unresolvable parent is dropped harmlessly - the gateway logs a warning and continues, it does not terminate the session or poison the subscription.

That makes the subscription itself a discovery mechanism: add candidate codes, deploy, see which deliver definitions. Strictly better than trusting a documentation search, and we proved it - SO came from a plausible-looking source and was simply wrong. The feed is the authority on what the feed accepts.

Two guardrails made this safe:

Only map codes to roots you can price correctly. A wrongly-mapped option lands under a ghost ticker, which is a missing chain - annoying but visible. But if the mapped root is one whose price is quoted in cents or points of par, a wrong mapping can also miss a divide-by-100 and produce numbers wrong by two orders of magnitude while looking entirely reasonable (see the 100x notional trap). Ordering matters: our code applies the product-to-root mapping before resolving the contract multiplier, so a correctly-mapped OZN inherits the 10-year note's conventions automatically.

Verify with a property the data must satisfy. For energy we did not just check that a chain appeared; we checked that its strikes clustered near the underlying's price. Crude trades near 79 and heating oil near 4. A chain of heating-oil strikes filed under crude is instantly visible, and no amount of documentation-reading gives you that assurance.

It Bit Us Twice

The most instructive part is that fixing the live subscription did not fix the product.

Settled open interest - which every gamma, delta and max-pain figure depends on - is recovered through a separate historical backfill path. That code constructs its own request:

symbols=GC.OPT

Identical assumption, different file, written at a different time. It returned HTTP 422 for every cross-asset root, and 0 roots, 0 contracts for the operation as a whole, while reporting itself complete.

So the chains were populated and the exposure numbers were still zero.

Takeaways

• Parent symbology is keyed on the product code, not the underlying. Options frequently have a different product code from their own futures contract.
• The mapping is not derivable. GC -> OG, ZN -> OZN, CL -> LO. Look them up and verify each.
• Not every product does it. Silver and NZD options carry the futures root. Check, do not extrapolate.
• Use the feed as the authority. Unresolvable parents are dropped harmlessly, so subscribe-and-observe beats documentation.
• Verify with a property, not a status code. Strikes clustering near the underlying proves the mapping; a 200 response does not.
• Grep for the assumption, not the bug. The same wrong symbol was constructed in two independent places.
• Zero results is a failure, especially in a backfill whose entire job is to produce results.

The most uncomfortable part of this was how healthy everything looked. Definitions streaming, prices correct, health checks green, no errors anywhere - and the product's headline metric silently zero for an entire asset class. A subscription that accepts your request is not the same as a subscription that returns your data, and the gap between those two is exactly where silent failures live.