How to Connect Cursor to Live Stock Market Data (MCP Setup)

Connecting Cursor to live market data means the AI editor answers from the current tape instead of stale training memory. Once you wire the SNACS MCP server into Cursor, you can type a plain-English question like "which small-caps traded over 100 million shares this week and what was their true MFE" and get back real numbers: RVOL, float, per-session OHLC, dilution facilities, and recent SEC filings. This is the same data the scanner streams, exposed to the model you already code with. Below is the exact setup, then worked examples using last week's runners so you can see what the answers actually look like.

TLDR

• Cursor's MCP support lets the editor call the SNACS market-data server, so questions about RVOL, float, session OHLC, dilution facilities, and SEC filings return live values rather than a guess from training data.
• Setup is one JSON block in Cursor's mcp.json plus a SNACS API key. Full config is in the setup section below, and it takes about five minutes.
• Worked with real data (Aug 19-25): ZSTK ran from a $1.52 low to a $12.40 high on Aug 19 for a +715.8% true MFE, and BTCT gained +317.7% over five sessions while carrying 18.0% short interest.
• The macro backdrop is Small-Cap Leadership. The Russell 2000 (IWM) closed at $299.23, within 5% of its 52-week high, the tape most likely to reward these setups.
• You'll learn what to query, how to turn a Cursor answer into a saved scanner filter, and where the setup silently breaks if you skip the API key.

What Is MCP and Why Connect Cursor to Market Data?

MCP (Model Context Protocol) is an open standard that lets an AI tool call an external data source through a defined server, so the model answers from live data instead of its training set. Connecting Cursor to the SNACS MCP server turns the editor's chat panel into a market-data terminal: you ask a question in plain English, Cursor calls the server, and current scanner values come back inline.

The reason this matters for a trader who codes is precision. A general model does not know what BTCT did on Aug 19, and if you ask, it will either refuse or fabricate. With the MCP connection live, the same question resolves against the actual database: BTCT opened at $0.48, printed a $1.32 high, closed the regular session at $0.82 (up +71.9%), and its full-day true MFE from the $0.47 low to the after-hours $1.77 print was +369.2% on 147.5M shares. Those are not numbers the model invented. They are pulled from the same feed powering the SNACS scanner.

Cursor is a natural home for this because the people using it are already building. If you write Python to backtest a float-rotation idea, you want the model drafting that code to see the real float, the real volume, and the real dilution overhang while it works, not a plausible-looking placeholder. The MCP server closes that gap. You can prototype a scanner rule, ask Cursor to validate it against last week's tape, and iterate without leaving the editor.

This is the same protocol behind our other integrations. If you want the conceptual grounding first, read What Is an MCP Server for Stock Market Data? A Trader's Reference, and if you are curious how the server itself was built, Building an MCP Server for Live Market Data: What We Learned covers the engineering. Cursor, Claude Code, and VS Code Copilot all speak the same standard, so the setup pattern below transfers to each of them.

One framing point before the config. MCP does not turn Cursor into a broker or an order-routing tool. It is read access to market data: scanner state, session breakdowns, dilution facility counts, and filing history. You still place trades in your own platform. What you gain is a research assistant that reasons over current numbers, which is exactly what you want when a name like DAIC runs +756.8% over five sessions and you need to understand the structure behind the move before you touch it.

The 5-Minute Cursor MCP Setup

Connecting Cursor takes one configuration file and an API key. Cursor reads MCP servers from a JSON file, so you add the SNACS server entry, paste your key, and restart. Here is the full procedure.

The server block itself is short. In Cursor's mcp.json, add the SNACS entry under mcpServers:

{
  "mcpServers": {
    "snacs": {
      "url": "https://api.snacs.trade/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_SNACS_API_KEY"
      }
    }
  }
}

Replace YOUR_SNACS_API_KEY with the key from your account settings. If you already have other MCP servers configured, add the snacs block alongside them inside the existing mcpServers object rather than creating a second one. Save the file, then fully quit and reopen Cursor. On restart, Cursor registers the server and its tools become available to the chat.

To confirm it worked, open the Cursor chat and ask something that can only be answered from live data, for example "using SNACS, what small-caps posted the highest true MFE last week." If the connection is live, Cursor makes a tool call and returns real tickers with real numbers. If it answers vaguely or says it cannot access market data, the server did not register, and the pitfalls section below covers why.

For a project-scoped setup, put the same JSON in .cursor/mcp.json at the repository root instead of the global path. That keeps the connection tied to a specific trading-research repo, which is useful if you share the project or want the key isolated per workspace.

What You Can Actually Ask Cursor Once It's Connected

Once connected, Cursor answers structured market questions in plain English, and the most useful queries mirror how you already scan. The point is not novelty, it is that the model reasons over current values. Here are query shapes that return meaningful answers, anchored to last week's tape (Aug 19-25).

Volume and RVOL screening. Ask "which small-caps traded over 100 million shares last week" and the answer includes names like NCPL, which ran 498.1M shares on Aug 25 (up +116.6% in the regular session), and HOWL, which totaled 377,474,763 shares across its five-session run. Over the past week, 22 setups traded 100M or more shares intraday, and across the last 30 days the high-volume breakout pattern, defined as at least 100M shares traded intraday, saw 133 setups trigger and all 133 reach target, a 100% follow-through read.

Session breakdown. Ask "show me the pre-market, regular, and after-hours split for SWVL on Aug 25" and you get the full picture that a single close price hides. SWVL printed a $3.47 pre-market high, opened the regular session at $2.31, ran to $2.50, faded to $1.88, and closed at $2.22, down -3.9% on the day. Yet its true MFE from the $1.40 low to the $3.47 high was +147.8%. A trader reading only the red close would have missed that the day offered a large intraday window.

Dilution and structure. Ask "what is the dilution overhang across the tracked universe" and the answer surfaces the facility landscape: roughly ~5,900 active warrant facilities, ~3,100 active shelves, ~2,100 active ATM programs, ~1,400 convertible notes, ~900 convertible preferred facilities, ~700 S-1 offerings, and ~500 equity lines. Narrow it to a single name and you get that ticker's specific facilities, which is the read you want before buying into a runner.

Filing activity. Ask "how many offering filings landed in the past three days" and Cursor returns exact counts: 14 total 424B5 pricing supplements from 8 unique tickers, 7 fresh S-3 shelf registrations from 7 unique tickers, and 195 8-K filings across 181 unique tickers. Those are the counts you use to gauge how heavy the dilution calendar is running.

Worked Example: Reading ZSTK's +715.8% Session Through Cursor

ZSTK is the cleanest illustration of why live data beats memory, because its Aug 19 session was mechanical and the numbers are extreme. Ask Cursor "walk me through ZSTK on Aug 19 with full session data," and here is what comes back.

ZSTK opened the regular session at $2.29, ran to a $12.40 high, and closed at $4.88, up +113.1% on the day, on 24.3M shares against a 1253.6x ADV read. Its full-day true MFE from the $1.52 low to the $12.40 high was +715.8%. The after-hours session settled back to $4.27. Over the full five-session window it moved from $2.29 to a $6.45 close, a +181.7% run.

The catalyst was a filing-and-disclosure sequence, not earnings. Zerostack Corp. reported cryptocurrency holdings with an aggregate market value of approximately $1.06 billion, representing approximately $18.19 per partially diluted share (press release, Aug 24), following an earlier disclosure of a US$1.0 billion strategic contribution of Memecore tokens at US$25.19 per share (press release, Aug 19). That is a structure-and-catalyst story, exactly the kind of setup where you want the model quoting the actual disclosure rather than paraphrasing from memory.

The profit math frames the opportunity. A $10,000 position entered at the $1.52 low and exited at the $12.40 high captured the full +715.8% MFE, turning into $81,580. Nobody nails the absolute low and absolute high, so the more realistic open-to-close trade is the honest number: entering the $2.29 open and holding into the $4.88 close captured +113.1%, turning $10,000 into $21,310. Both figures come from the same session data, and both are worth internalizing, because the gap between them is the difference between a fantasy fill and a repeatable process.

ZSTK also shows up in the liquidity-test pattern set, where market makers probe a price level to test supply and demand before the real move. Over the past week, 111 liquidity tests were detected and all 111 completed. Reading those probes is a skill on its own, and Trading the Probe: How Market Makers Test Small-Cap Liquidity breaks down the mechanics.

Worked Example: BTCT, Short Interest, and the Continuation Read

BTCT demonstrates a second query pattern: pairing a multi-day runner with its short interest and float to judge whether the move has fuel left. Ask Cursor "give me BTCT's five-day run, short interest, and float tier," and the answer stacks the pieces.

BTCT gained +317.7% over five sessions, from $0.48 to a $2.00 close, with a peak single-day volume of 185,517,582 shares and 525,561,759 shares total across the run. It carries 18.0% short interest, sits in the nano-cap tier under $50M, and shows a float in the 5-25M share band. On Aug 19 alone it opened at $0.48, ran to $1.32, closed the regular session at $0.82 (up +71.9%), and printed a $1.77 after-hours mark for a full-day true MFE of +369.2% on 147.5M shares.

The catalyst chain was contract and infrastructure news: BTC Digital signed a three-party MOU to advance an AI data center project in Hai Phong, Vietnam (press release, Aug 25), following a disclosure that its Georgia 10MW cryptocurrency computing infrastructure was approaching deployment readiness (press release, Aug 24). Elevated short interest plus a tight float plus a fresh catalyst is the classic squeeze scaffold, and the macro tape supports it: with the Russell 2000 (IWM) at $299.23, within 5% of its 52-week high, small caps are leading, and squeezes follow through more readily when the small-cap complex is bid.

Contrast BTCT with ADXN, which ran to a +220.8% true MFE on Aug 21 (pre-market high $14.75, regular open $5.87, high $6.05, low $4.60, close $4.91, down -16.4% on the day) on the back of an ATM raise. ADDEX raised fresh capital through its ATM agreement and extended cash runway to the fourth quarter 2027 (press release, Aug 26). ADXN sits in the negative-cash tier, so the raise is the mechanism, and the red close against a huge MFE is the tell that the move was a supply event, not a durable trend. Asking Cursor to surface the cash tier alongside the price action is how you separate the two setups in seconds.

Common Pitfalls

Most failed Cursor MCP setups trace to three mistakes, and all three are quick to fix. The first is skipping the restart. Cursor loads MCP servers on launch, so editing mcp.json while the app is open does nothing until you fully quit and reopen. If your test question gets a vague answer, restart before assuming the config is wrong.

The second is an invalid or unscoped API key. If the Authorization header is missing, malformed, or pasted with a trailing space, the server rejects the call and Cursor falls back to answering from training data, which looks like success but is fabrication. The tell is that the answer has no specific tickers or session numbers. Always verify with a question that can only be answered live, such as a named ticker's exact MFE, and confirm the model actually made a tool call.

The third is trusting a number without the session context. This is a trading mistake, not a setup mistake, but it bites hardest. When Cursor returns that SWVL closed down -3.9% on Aug 25, that is true and also incomplete: the same day offered a +147.8% MFE from the $1.40 low to the $3.47 high. Small-cap days routinely close red after offering large intraday windows, so always ask for the full session breakdown, pre-market, regular, and after-hours, before you judge a move. A single close price is the least useful number in small-cap trading.

One more framing pitfall worth naming: do not read a stock's low offering price on one date and a higher price on a later date as an improving or weakening position. Reverse splits are constant in this universe, and a raw price comparison across dates is meaningless without checking whether a split occurred. Ask Cursor for the split history explicitly rather than inferring a trajectory from two prices.

How to Apply This: From Cursor Query to Scanner to Playbook

The workflow that pays off is using Cursor to find the shape, then the scanner to catch it live. Cursor is excellent for research and hypothesis testing over historical tape. The SNACS scanner is where you act in real time. Chain them.

Start in Cursor by asking for the common structure across last week's runners: what float band, what RVOL, what dilution profile. When you notice that names like BTCT and ZSTK shared tight floats and fresh catalysts, translate that into a saved scan. In the scanner, set an RVOL floor, a float ceiling in the 5-25M range, a volume minimum, and turn on the dilution alerts column. Save it as a named preset so it persists.

Then link that saved scan to a Dynamic Watchlist, the scan-to-watchlist auto-sync that repopulates in real time as new tickers match. Matches show a colored square in the main stream, so you see fresh candidates the moment they qualify, without re-running anything. Click any ticker to open its details page and read the dilution risk panel, recent filings, and news in one view, which is the same structure data Cursor was quoting, now attached to a live chart.

For the pattern itself, the AI Playbook Builder lets you describe the setup in plain English and get working detection logic, then it live-matches against every scanner ticker and drops a star indicator when a name fits. If you want the walkthrough, Describe a Trading Setup in Plain English. Get Working Detection Logic. shows the flow. For the dilution read, the SEC research tool answers natural-language filing questions and gives a dilution snapshot with active facility counts and the lowest exercise price, the second path to the same structure data you can also see in the scanner's dilution column.

Finally, close the loop in your trading journal. After you take a setup you first spotted through a Cursor query, the AI Insights layer analyzes your pattern, your best and worst times of day, and your MFE capture rate, so you learn whether you are actually catching the windows you researched or leaving them on the table like the ZSTK open-to-high gap. If you want the broader pattern context that informs which setups to build, Pattern Recognition for Penny Stocks: What 90 Days of Scanner Data Shows is the reference.

Conclusion: What to Watch Next

Connecting Cursor to SNACS gives you a research assistant that reasons over the live tape, and the setup is a single JSON block plus a key. The habit that compounds is asking for full session data and structure, float, short interest, dilution facilities, cash tier, before you judge any move, because the red-close-big-MFE pattern that ADXN and SWVL showed last week is the norm, not the exception. With the macro backdrop in Small-Cap Leadership and the Russell 2000 (IWM) within 5% of its 52-week high, the continuation names from last week's runner list are the watch set. Point Cursor at them, read the structure, then let the scanner and playbook catch the next one live.

FAQ

What is Cursor MCP and how does it connect to stock market data?

Cursor MCP is Cursor's support for the Model Context Protocol, an open standard that lets the AI editor call an external data server and answer from live data. Connecting it to the SNACS MCP server gives Cursor read access to live scanner values: RVOL, float, per-session OHLC, dilution facilities, and SEC filings. You add one server block to Cursor's mcp.json, paste your API key, restart, and then ask market questions in plain English.

How do I set up the SNACS MCP server in Cursor?

Generate a SNACS API key in your account settings, open ~/.cursor/mcp.json (or .cursor/mcp.json in a project), and add a snacs server block pointing to https://api.snacs.trade/mcp with an Authorization: Bearer YOUR_SNACS_API_KEY header. Save the file, fully quit and reopen Cursor so the server registers, then confirm by asking a question that can only be answered from live data, such as a named ticker's exact MFE.

Why does Cursor give vague answers instead of real market data?

The most common cause is not restarting Cursor after editing mcp.json, since the app loads MCP servers only on launch. The second cause is an invalid or malformed API key, which makes the server reject the call and Cursor fall back to training data. Test with a specific live question, for example ZSTK's Aug 19 session, and if the answer lacks exact tickers and session numbers, the connection is not active.

Can Cursor place trades or route orders through MCP?

No. The SNACS MCP connection is read access to market data only: scanner state, session breakdowns, dilution facility counts, and filing history. It does not execute trades or route orders. You use Cursor for research and hypothesis testing, then act in your own trading platform, using the SNACS scanner to catch setups live.

What kinds of questions can I ask Cursor once MCP is connected?

Ask for volume and RVOL screens (which small-caps traded over 100M shares last week), session breakdowns (the pre-market, regular, and after-hours split for a ticker), dilution structure (active shelf, ATM, and warrant facility counts), and filing activity (how many 424B5 or S-3 filings landed in the past three days). For example, 14 total 424B5 filings from 8 unique tickers and 7 fresh S-3 registrations hit in the past three days.

Why is true MFE more useful than the closing price for small-caps?

True MFE (Max Favorable Excursion) measures the best possible trade from the day's low to its high across all sessions, which captures the intraday window a closing price hides. SWVL closed down -3.9% on Aug 25 but offered a +147.8% MFE from its $1.40 low to its $3.47 high. A stock can close red and still have offered a large day-trade window, so always read the full session data, not just the close.

Does the Cursor MCP setup work the same for other AI tools?

Yes. MCP is an open standard, so the same server and key work across Cursor, Claude Code, and VS Code Copilot with tool-specific config paths. The VS Code Copilot integration and Claude Code integration follow the same pattern, and the SNACS v2.0 launch covers the Data API and MCP server that power all of them.

How do I turn a Cursor research answer into a live scanner setup?

Use Cursor to find the common structure across recent runners (float band, RVOL, dilution profile), then build a saved scan in the SNACS scanner with those filters and link it to a Dynamic Watchlist that auto-populates as new tickers match. Add the pattern to the AI Playbook Builder for live star-indicator matching, and track your fills in the trading journal so AI Insights shows your real MFE capture rate.