To get option prices in Claude, connect the MarketXLS MCP (Model Context Protocol) server to Claude, confirm the connection by asking for a quote with a timestamp, and then ask in plain English, for example "what is the implied volatility on the QQQ 700 call expiring in September?" Claude calls MarketXLS functions such as QM_GetOptionChain and QM_GetOptionQuotesAndGreeks and answers with current data instead of a guess from training data. Options data is end-of-day on the MarketXLS Standard plan and real-time on the Advanced and Business plans. This guide covers the setup, the functions behind each answer, a query workflow, validation checks, and a companion Excel workbook that uses the same functions.
Try it in your own spreadsheet
Get the free MarketXLS sample workbook (.xlsx).
No account needed. MarketXLS live data requires a paid plan. Preview workbook
Explore more videos
option prices in Claude: what a grounded answer looks like
Below is the kind of option board the connector can return. This is a static QQQ snapshot for the 2026-09-18 expiry, captured on 2026-07-30 with the underlying near $702.40, so you can study the shape of the output. The point is not the exact premiums, which move constantly, but that every figure maps to a specific MarketXLS function rather than to something the model produced from memory.
| Contract | Bid | Ask | Last | Implied Vol | Delta | Open Interest |
|---|---|---|---|---|---|---|
| QQQ 690 Call | $26.35 | $27.00 | $26.70 | 18.6% | 0.63 | 14,700 |
| QQQ 700 Call | $20.45 | $21.00 | $20.75 | 18.1% | 0.54 | 26,300 |
| QQQ 710 Call | $15.30 | $15.85 | $15.60 | 17.9% | 0.45 | 17,900 |
| QQQ 700 Put | $19.50 | $20.05 | $19.80 | 19.2% | -0.46 | 24,800 |
| QQQ 710 Put | $24.35 | $24.95 | $24.65 | 18.9% | -0.55 | 12,400 |
Options analysis has historically required either a dedicated trading platform, an expensive terminal, or a carefully maintained spreadsheet full of volatile formulas. The MCP connector collapses that stack. The AI assistant becomes the interface and MarketXLS becomes the data engine behind it. What follows is how that actually works in practice.
What it means to access option prices in Claude
There is an important distinction to make before anything else. A language model has no market data of its own. Whatever it learned during training is frozen at a cutoff date, and option premiums move by the second. Any answer a model gives about a live premium without a tool call is a guess dressed in confident prose.
The connector changes the mechanism, not just the convenience. When the MarketXLS MCP server is attached to your Claude session, the assistant stops answering from memory and starts issuing structured requests to a licensed data layer. The model's job becomes reasoning, formatting, and explanation. The data's job stays with MarketXLS. That separation is what makes a conversational options workflow trustworthy enough to build on.
It also means the failure mode is visible. If the connector is not attached, Claude will tell you it cannot access real-time data rather than inventing a number. That is the behaviour you want, and it is worth confirming deliberately before you rely on any output. There is a step for exactly that below.
How the MarketXLS MCP connector works
The Model Context Protocol is an open standard that lets AI assistants call external tools in a structured, permission-aware way. MarketXLS exposes its financial-data functions through an MCP server. When you connect Claude, or any other MCP-compatible assistant, to that server, the assistant gains the ability to invoke those functions on your behalf during a conversation.
The flow looks like this:
- You ask a question in natural language inside Claude.
- Claude identifies which MarketXLS function is appropriate and constructs a structured request with the ticker, expiry, strike, and contract type.
- The MarketXLS MCP server receives the request, resolves it against the same data layer that powers the Excel add-in, and returns a structured response.
- Claude interprets the response and presents it as prose, a table, or whatever format you asked for.
From your side it feels like talking to an analyst who happens to have a live data feed open. Underneath, every number is sourced from MarketXLS infrastructure rather than from model weights, which is the critical distinction for anything as time-sensitive as an option premium.
The other consequence worth understanding is consistency. Because the connector publishes the same functions the Excel add-in uses, a chat answer and a spreadsheet cell resolve to the same source. You are not reconciling two vendors. You are looking at one data layer through two interfaces.
What options data is available through the connector
The connector surfaces a broad set of options data points you can query conversationally. Here are the categories and the MarketXLS functions that back them.
| What you ask for | Function behind the answer | What it returns |
|---|---|---|
| A whole chain with Greeks | =QM_GetOptionQuotesAndGreeks("QQQ") | Full chain plus Greeks, spilled as a table |
| A specific contract symbol | =OptionSymbol("QQQ","2026-09-18","Call",700) | The OCC contract symbol |
| Bid and ask on one contract | =Option_Bid(...) / =Option_Ask(...) | Live bid and ask |
| Last traded price | =Option_Last_Price(...) | Last print on that contract |
| Open interest and volume | =Option_OpenInterest(...) / =Option_Volume(...) | Existing positions and today's activity |
| Per-contract implied volatility | =opt_ImpliedVolatility(Spot, Price, Expiry, Type, Strike) | Solved IV for that contract |
| The Greeks | =opt_Delta(...), =opt_Gamma(...), =opt_Theta(...), =opt_Vega(...), =opt_Rho(...) | Model Greeks per contract |
| Underlying volatility context | =ImpliedVolatility30d("QQQ"), =ImpliedVolatilityRank1m("QQQ") | 30-day IV and where it sits in its recent range |
| Sentiment and activity | =opt_PutCallVolRatio("QQQ"), =opt_PutCallOIRatio("QQQ") | Put/call ratios on volume and open interest |
| Aggregate chain activity | =opt_TotalVolumeOptions("QQQ"), =opt_TotalOpenInterestOptions("QQQ") | Total contracts traded and total open interest |
| Filtered chain slices | =QM_GetOptionChainAtTheMoney("QQQ"), =QM_GetOptionChainWeeklies("QQQ") | Near-the-money and weekly subsets |
| Model value for a contract | =BlackScholesOptionValue(Symbol, RiskFreeRate, Volatility) | Theoretical value under stated assumptions |
Data may be live or delayed depending on your MarketXLS plan and the exchange in question. Confirm the timestamp on any quote before acting on it, especially for fast-moving underlyings or contracts close to expiration. Details on plan levels are on the MarketXLS pricing page.
Step-by-step workflow: querying option prices in Claude
Here is a practical, repeatable sequence for pulling options data through Claude.
Step 1: connect the MarketXLS MCP server
Open your Claude environment, whether that is claude.ai or a desktop client that supports MCP. Go to the connectors or tools settings and add the MarketXLS MCP server using the connection details in your MarketXLS account. Once connected, Claude will list the available MarketXLS tools if you ask it to describe what it can do.
Step 2: confirm the connection is live before you trust anything
This step is not optional. Ask something with a verifiable answer:
"Using MarketXLS, what is the current price of QQQ?"
If you get a real number with a timestamp, the connector is working. If Claude answers from memory, hedges about a knowledge cutoff, or says it cannot access real-time data, the server is not attached and nothing that follows will be grounded.
Step 3: request an option chain
Ask for a chain in plain language, and be specific about the fields you want back:
"Show me the QQQ options chain for the 2026-09-18 expiry, strikes 680 through 730, with bid, ask, last, implied volatility, delta, and open interest for calls and puts."
Claude invokes the appropriate MarketXLS function, retrieves the chain, and formats the output. You can bound the strike range, ask for only in-the-money or out-of-the-money contracts, or restrict the result to a handful of strikes around the current price.
Step 4: drill into a single contract
Once you have the chain, narrow the focus:
"What are the theta and vega on the QQQ 700 call expiring 2026-09-18?"
The assistant calls the Greek functions for that specific contract. You can then follow up with reasoning questions such as "how much would this contract lose if implied volatility dropped two points?" and Claude will work through the answer using the vega figure it just retrieved rather than a remembered rule of thumb.
Step 5: evaluate a spread
For multi-leg structures, ask Claude to price both legs and compute the net:
"Price the QQQ 700/720 call vertical for the 2026-09-18 expiry. Give me the net debit, max profit, max loss, and breakeven."
Claude queries each leg, computes the net debit or credit, and walks through the risk profile. Worth stating plainly: this is a structured data summary, not a recommendation. The arithmetic tells you what the position's boundaries are, not whether the position is a good idea.
Step 6: hand the data to a spreadsheet
If you want to preserve the output or model it further, ask Claude to format it as CSV or a Markdown table you can paste into Excel or Google Sheets. Because MarketXLS also provides native Excel functions, you can rebuild the same board as a live workbook and let it refresh on its own.
Reading and interpreting the response
Getting the data is the easy part. Reading it correctly is where the work is.
Timestamp. Every response should carry a timestamp or a note about whether the data is live or delayed. Near expiration, even a fifteen-minute delay can make a contract look mispriced when it is not.
Bid-ask spread. On illiquid strikes the spread can be punishing. The midpoint is usually a better estimate of fair value than either side alone, but you will rarely fill there on a wide market. In the sample board above, the QQQ 700 call shows a $0.55 spread on a $20.75 premium, which is roughly 2.6% of the contract's value in friction before anything else happens.
Implied volatility against realised volatility. Implied volatility reflects what the market expects. If you want to know whether that expectation looks rich or cheap against what the underlying has actually delivered, ask Claude to pull =ImpliedVolatility30d() alongside =StockVolatilityOneYear() and compare. That comparison is a starting question, not an answer.
Delta as a rough probability proxy. Delta is often read as an approximation of the probability a contract finishes in the money. A 0.30 delta call is loosely around 30% likely to expire in the money under a Black-Scholes framework. It is a useful shorthand and a genuine simplification, since it ignores skew and the difference between risk-neutral and real-world probability.
Open interest against volume. High open interest means positions already exist. High volume means activity is happening today. A contract with heavy open interest and thin volume can still be hard to trade at a good price.
Sign and range on the Greeks. Call delta belongs between 0 and 1, put delta between -1 and 0, gamma is positive, and theta is negative on long options. A value outside those ranges is a signal to re-query rather than to reinterpret.
Combining AI analysis with an Excel handoff
The most useful pattern with this connector is hybrid. Use Claude for fast conversational exploration, then hand structured data to a spreadsheet for anything you need to monitor or audit.
A typical session looks like this:
- In Claude: compare implied volatility and IV rank across a handful of underlyings using
=ImpliedVolatility30d()and=ImpliedVolatilityRank1m(). - In Claude: pull the chain for whichever names look interesting and identify the strikes with workable liquidity.
- Export: ask Claude for a table of the selected contracts with every field you care about.
- In Excel: rebuild that table with live MarketXLS functions so it updates through the trading day instead of going stale the moment you paste it.
The conversation gives you speed during discovery. The workbook gives you rigour and an audit trail during monitoring. Neither one is a good substitute for the other.
The companion workbook
Both files below carry the same seven-sheet structure, and the formula version uses only functions verified against the MarketXLS catalogue.
| Sheet | What it does |
|---|---|
| How To Use | Workflow notes, what MCP is, a prompt library you can paste into Claude, and links |
| Option Chain Board | Ticker and expiry inputs plus bid, ask, mid, last, spread, IV, open interest, volume, and a liquidity score per strike |
| Greeks and IV | Delta, gamma, theta, vega, and rho per contract, with IV rank and percentile on the underlying |
| Scenario Analysis | Re-prices one contract across underlying moves, an implied-volatility shift, and elapsed days |
| Spread Builder | Vertical spread economics: net debit, max profit, max loss, breakeven, and net Greeks |
| Position Sizing | What a stated account size and risk budget imply in contracts |
| Underlying Comparison | IV, IV rank, realised volatility, put/call ratios, and option activity across several tickers |
The Option Chain Board is where the ticker and expiry live. Change those two yellow cells and every other sheet re-points to the new chain, because each downstream sheet references them rather than repeating them.
Here is the core of the chain sheet in the formula version:
Contract symbol =OptionSymbol($B$3,$B$4,$A9,$B9)
Bid =Option_Bid($C9)
Ask =Option_Ask($C9)
Last =Option_Last_Price($C9)
Spread =$E9-$D9
Implied vol =opt_ImpliedVolatility($B$5,$G9,$B$4,$A9,$B9)
Open interest =Option_OpenInterest($C9)
Volume =Option_Volume($C9)
Formula documentation: OptionSymbol, opt_ImpliedVolatility
The Greeks sheet pulls its contract symbols and premiums from the chain and then solves each Greek off the live spot:
Delta =opt_Delta($E$4,$D10,$B$5,$A10,$B10)
Gamma =opt_Gamma($E$4,$D10,$B$5,$A10,$B10)
Theta =opt_Theta($E$4,$D10,$B$5,$A10,$B10)
Vega =opt_Vega($E$4,$D10,$B$5,$A10,$B10)
Rho =opt_Rho($E$4,$D10,$B$5,$A10,$B10)
Formula documentation: opt_Delta, opt_Gamma, opt_Theta, opt_Vega, opt_Rho
The Spread Builder prices both legs conservatively, using the ask on the leg you buy and the bid on the leg you sell, so the net debit reflects a realistic fill rather than a midpoint that may not exist:
Long leg symbol =OptionSymbol($B$4,$B$5,"Call",$B$6)
Short leg symbol =OptionSymbol($B$4,$B$5,"Call",$B$7)
Buy at =Option_Ask($B$10)
Sell at =Option_Bid($B$11)
Net debit =$B$12-$B$13
Max profit =($B$7-$B$6)-$B$15
Breakeven =$B$6+$B$15
Formula documentation: OptionSymbol
The Underlying Comparison sheet is the one that most closely mirrors a Claude conversation, because it is the board you would ask for when you do not yet know which name you care about:
=QM_Last($A5)
=ImpliedVolatility30d($A5)
=ImpliedVolatilityRank1m($A5)
=StockVolatilityOneYear($A5)
=opt_PutCallVolRatio($A5)
=opt_PutCallOIRatio($A5)
=opt_TotalVolumeOptions($A5)
=opt_TotalOpenInterestOptions($A5)
Formula documentation: QM_Last, ImpliedVolatility30d, ImpliedVolatilityRank1m, StockVolatilityOneYear, opt_PutCallVolRatio, opt_PutCallOIRatio, opt_TotalVolumeOptions, opt_TotalOpenInterestOptions
Download the templates:
- - pre-filled snapshot so you can study the layout, with the formula behind each column shown alongside
- - live formulas that refresh when you recalculate
Every sheet in both files carries a "MarketXLS Functions Used in This Sheet" box at the bottom, so you can see exactly which function produced each column without reverse-engineering a cell.
What the scenario grid actually shows
The Scenario Analysis sheet is worth a closer look, because it makes a point that gets lost in conversational answers. It estimates a new premium as:
premium + (delta x move) + (0.5 x gamma x move^2) + (vega x IV change) + (theta x days)
Run that on the QQQ 700 call from the snapshot above, assuming implied volatility falls one point and five days pass:
| Underlying move | Delta term | Gamma term | Vega term | Theta term | Est. premium |
|---|---|---|---|---|---|
| -$20 | -$10.80 | $1.46 | -$1.46 | -$1.20 | $8.75 |
| -$10 | -$5.40 | $0.37 | -$1.46 | -$1.20 | $13.06 |
| $0 | $0.00 | $0.00 | -$1.46 | -$1.20 | $18.09 |
| +$10 | $5.40 | $0.37 | -$1.46 | -$1.20 | $23.86 |
| +$20 | $10.80 | $1.46 | -$1.46 | -$1.20 | $30.35 |
Look at the flat row. The underlying has not moved at all, and the contract is still worth $2.66 less than where it started. That is the volatility and time cost of being early, and it is something directional options views often underestimate. A conversational answer will tell you the delta. The grid tells you what happens when delta is not the only thing that changes.
This is a second-order approximation and not a substitute for a full re-price, particularly for large moves or contracts close to expiry. It is a framing tool.
Validation and data-quality checks
Never treat a single source as ground truth for options data, and that includes this one. Run these checks.
Cross-reference the underlying price. Before trusting any option quote, confirm the underlying price returned by MarketXLS matches what your broker shows. A discrepancy of more than a few cents on a liquid name is worth investigating before you look at anything downstream.
Check the expiration date. Expiries are easy to get subtly wrong, since weeklies, monthlies, and quarterlies can sit close together, and AM versus PM settlement matters on index products. Confirm the exact date in the response is the contract you meant.
Verify open interest is non-zero. A contract with zero open interest may be newly listed or genuinely untradable. Pricing on such contracts is unreliable regardless of what any data source reports.
Sanity-check the Greeks. Call delta between 0 and 1, put delta between -1 and 0, gamma positive, theta negative on long options. Anything outside those ranges means the inputs need a second look, not a creative interpretation.
Confirm data freshness. Ask Claude directly: "when was this data last updated?" If the connector cannot produce a timestamp, treat the figure as potentially stale.
Re-check after a market-moving event. Around an earnings release or a scheduled macro print, implied volatility can move materially within minutes. A board pulled fifteen minutes ago may describe a different market.
Troubleshooting common issues
Claude says it cannot access real-time data. The MCP server is not connected, or the session has timed out. Return to your connector settings, confirm the server is listed and enabled, and start a fresh conversation.
The option chain returns no results. Usually the ticker is misspelled, the underlying has no listed options, or the expiry you named does not exist for that name. Ask Claude to retrieve the available expirations first, then re-query against one of them. =IsOptionable() answers the "does this even have options" question directly.
Greeks are missing. Some contracts, particularly deep in-the-money LEAPS and very illiquid strikes, may not have Greeks calculated. Try a more liquid strike closer to at-the-money.
The bid is zero or the ask is very wide. That is a liquidity condition, not a connector fault. The contract has little market-maker activity. Move to a more liquid strike or expiry.
Prices look stale against your broker. Confirm whether your plan provides live or delayed data for the relevant exchange. Delayed feeds typically run fifteen minutes behind, which is fine for research and not fine for anything near expiration.
Numbers differ slightly from your broker's Greeks. Greeks are model outputs, not observed data. Different platforms use different volatility inputs, risk-free rates, and dividend assumptions. Small differences are expected. Large ones mean the inputs differ somewhere.
FAQ
Can I use the MarketXLS MCP connector with AI assistants other than Claude? The MCP standard is assistant-agnostic by design. Any assistant that supports the Model Context Protocol can connect to the MarketXLS MCP server. Claude is one example, and the workflow in this guide applies broadly.
Is the options data live or delayed? That depends on your MarketXLS subscription and the exchange in question. Check your account details, and confirm the timestamp in any response before making a time-sensitive decision.
Can I ask Claude which options to buy or sell? Claude can summarise data, explain risk profiles, and compare structures. It does not provide individualised investment advice, and neither does MarketXLS. Use the data to inform your own research, and speak to a licensed professional for personalised guidance.
Does the connector support multi-leg strategy pricing? You can query individual legs and have Claude compute the combined economics, which is what the Spread Builder sheet does in Excel. Native multi-leg tooling varies by connector version, so check the current function set in the MarketXLS formula reference.
Can I save the options data pulled through Claude? Yes. Ask for the output as a Markdown table or CSV and paste it into a spreadsheet. Better still, rebuild the board with native MarketXLS functions so it refreshes on its own instead of freezing at the moment you copied it.
What underlyings are supported? MarketXLS covers a broad range of US-listed equities and ETFs with listed options markets. Coverage of index options, futures options, and non-US underlyings varies. Query a specific ticker to confirm availability.
Why do the workbook's Greeks differ slightly from the chain snapshot? The snapshot in the sample file is fixed at a moment in time, while the formula version solves the Greeks off whatever the live spot and premium are when you recalculate. They are meant to differ. That is the entire point of the formula version.
The bottom line
Pulling option prices in Claude through the MarketXLS MCP connector is a genuine shift in how derivatives data gets handled day to day. The conversational interface lowers the barrier to asking a question. The structured tool calls keep the numbers grounded in a licensed data layer rather than in model output. The spreadsheet handoff preserves the rigour that serious options work requires, because a conversation is a poor place to monitor a position that moves all day.
Start small. Confirm the connector is live, pull one chain, check the timestamp and the open interest, then rebuild that same board in the workbook and watch it update. Once the two views agree, you have something you can actually work from.
Everything here is educational. Option data are third-party data points, not recommendations, and none of it guarantees any outcome. Confirm every price with your broker before you act on it.
Explore what else the platform covers at MarketXLS, or book a demo to see the MCP connector and the Excel functions working against your own tickers.
