Trade through the Autoview MCP

Autoview · Early access

Autoview runs an MCP server. If you use an MCP-aware assistant, Claude Desktop, the claude.ai connectors, Claude Code, or anything else that speaks the Model Context Protocol, it can place trades through Autoview by calling its tools. You describe the order in plain terms, the agent fills in a typed schema, and Autoview turns that into a validated command and sends it to your broker.

This is new, and it is in early access. Today it runs against a Tradovate paper (simulation) account so you can wire up your agent and watch it work without risking a cent. Live Tradovate and the other exchanges follow once each has been through a live coverage pass. The rest of this guide shows you what the tools do, how the safety model protects you, and what a first order looks like.

The main tool: entry

The tool you'll call most is entry. It places (or previews) one order. You give it:

  • exchange and credentials for the venue you're trading. During early access that's TRADOVATESIM with your Tradovate simulation login.
  • symbol, side, and quantity. Quantity can be a plain number or a percentage of your balance, like 50%.
  • type: market, limit, ioc, fok, stop, or stop_limit. A price goes with priced types; a trigger goes with stops.
  • stopLoss and takeProfit when you want a fixed protective pair on the entry, or trailStop, trailActivate, and trailFrequency when you want the stop to trail price instead of sitting at a fixed level. Tradovate simulation is the venue that supports brackets today.
  • live: this is the switch that matters most. Leave it off and the order is previewed, not placed. Set it to true and the order goes to the broker. More on that next.

A trailing stop needs trailStop and trailActivate together, since a trail can't fire without both a distance and a level to arm at; trailFrequency controls how often it re-checks and defaults to 1 if you leave it out. Normally stopLoss and takeProfit have to come as a pair, both or neither, but a trail relaxes that: with a trail in the mix you can add just one of them, or both, alongside it.

A Tradovate simulation account has no live market-data feed: Tradovate charges separately for real-time CME data, and a Simulation account never has it. Autoview normally resolves a percent quantity or an attached bracket (stopLoss, takeProfit, trailStop) against a live quote it fetches for you, so on TRADOVATESIM that fetch has nothing to fetch from. Pass priceRef, an approximate current price for the symbol, alongside a percent quantity or any bracket field, and Autoview uses that instead of a live quote. A plain order with a fixed quantity and no bracket doesn't need it. Leave it out where it's needed and entry now rejects the call up front with a clear message, rather than the order failing later with a confusing exchange error.

// needs priceRef: percent quantity, no live quote on TRADOVATESIM
{"symbol":"MESU25","side":"buy","quantity":"50%","priceRef":5000,...}

// needs priceRef: a bracket attached to a market entry
{"symbol":"MESU25","side":"buy","quantity":1,
 "stopLoss":10,"takeProfit":20,"priceRef":5000,...}

// no priceRef needed: fixed quantity, no bracket
{"symbol":"MESU25","side":"buy","quantity":1,...}

One thing to know up front: entry hands the order to your broker's zone and returns straight away with a queued confirmation and a trace id. It does not wait for the fill. To see what the order actually did, you pass that trace to the second tool, events.

Reading the result: events

Because entry returns as soon as the order is queued, the outcome arrives separately. The events tool reads it: previews, fills, cancels, and any error the exchange sends back. Give it your account token and the trace id from entry, and it returns the events that order produced, newest first.

The exchange reports back out of band, so if the events are not there the instant you ask, wait a moment and call events again. A dry run shows up as the order Autoview built for you; a live order shows the real fill.

The dry-run default is the whole safety model

Every entry call is a dry run unless you explicitly set live to true. A dry run builds the exact command your order would become and reports it back as a preview you read with events, without touching the broker. Nothing is placed, nothing is risked.

That default is deliberate. An agent can misread an instruction, and you want to see what it decided before any money moves. Read the preview from events, confirm the symbol, side, size, and trigger are what you meant, and only then send the real thing. This is the same d=1 habit the testing and debugging guide teaches for the rest of Autoview, built into the MCP as the out-of-the-box behavior.

Before you start

Three things:

  • An Autoview account. The MCP checks your account to know what you're entitled to trade. Create one if you haven't.
  • A Tradovate simulation account with API access, so you have the Username, Password, CID, and Secret to hand to the tool. Your keys are passed on the call; Autoview does not store them.
  • An MCP-aware client such as Claude Desktop, a claude.ai custom connector, or Claude Code.

Get your token

Generate a token at /account/tokens/ (Account menu → MCP tokens): set a label, an expiry, and the scopes you want, then copy the token when it appears. It is shown once. Pass it as the token argument on every entry and events call.

Tokens can be dry-run only or live-enabled, and can be limited to specific exchanges. Revoke a token any time from the same page; agents using it lose access immediately.

Building a custom or agent client

Claude Desktop, the claude.ai connectors, and Claude Code all handle the MCP connection handshake for you. If you're wiring up your own client or an autonomous agent, one detail those tools hide is worth knowing: the first call to the MCP endpoint must be initialize. The response carries an Mcp-Session-Id header, and every call after that (including entry and events) needs to carry that same header back. A spec-compliant MCP SDK does this automatically; a hand-rolled HTTP client has to do it itself.

A minimal request shape, once you have a token from the previous step:

POST /mcp/ HTTP/1.1
Content-Type: application/json
Accept: application/json, text/event-stream

{"jsonrpc":"2.0","id":1,"method":"initialize","params":{
  "protocolVersion":"2025-06-18","capabilities":{},
  "clientInfo":{"name":"your-agent","version":"1.0"}}}

→ response carries: Mcp-Session-Id: <session-id>

POST /mcp/ HTTP/1.1
Mcp-Session-Id: <session-id>
Content-Type: application/json

{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{
  "name":"entry","arguments":{
    "exchange":"TRADOVATESIM","token":"av_mcp_...",
    "credentials":{"public":"...","private":"...","cid":"...","sec":"..."},
    "symbol":"MESU25","side":"buy","type":"market","quantity":1,
    "live":false}}}

credentials is your Tradovate simulation Username, Password, CID, and Secret, keyed as public, private, cid, and sec. Scope the token to the exchange you're calling and leave live off until you've read back a few dry-run previews through events and confirmed they match what you sent.

Your first order, as a dry run

Ask your agent for something concrete, for example: "On Tradovate sim, buy one MES with a stop entry at 5000." The agent calls entry with exchange set to TRADOVATESIM, your simulation credentials, the symbol, side, quantity, type of stop, and the trigger. Because you didn't ask to go live, no order is placed; entry hands back a trace.

Now the agent calls events with that trace and shows you what came back: the order Autoview built from your words. Check that the side, size, and trigger match your intent. If you added a stop-loss or take-profit, confirm both legs are present. This preview is your checkpoint.

Going live

When the preview looks right, tell your agent to place it for real, which sets live to true on the call. entry queues it and returns a fresh trace; a moment later events shows the fill. On a Tradovate simulation account that order fills against paper money, the safe place to build confidence before any of this touches a funded account.

A word on what "live" reaches today: Tradovate through the MCP is simulation only. The connector is the same one that will drive live Tradovate, and live access opens after a dedicated coverage pass. So during early access, live on TRADOVATESIM means a real fill on your paper account, exactly the rehearsal you want.

Where this is going

One broker, paper first, is the floor, not the ceiling. The same entry path already understands limit and stop orders, brackets, and percentage sizing. As each exchange clears its live coverage pass it joins the list, and live trading opens venue by venue. For now, wire up your agent against Tradovate sim, get comfortable reading the dry-run previews, and you'll be ready the day live access lands.

Create your account