Trade through the Autoview MCP

Autoview · Early access · Updated October 5, 2026

Autoview runs an MCP server with six tools: setup, entry, events, hooks, command, and alert. 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 them. 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. It doesn't read your TradingView alerts for you -- that's the existing webhook path, which runs on its own, with no agent involved. The MCP is a separate surface: an agent you're talking to can place a real order on your instruction, whether that instruction came from a TradingView chart you're both looking at or anywhere else. It can also help you set the webhook path up in the first place -- see building a reusable TradingView alert below.

This is new, and it is in early access. It places real trades today on Kraken (subscription required) and Crypto.com (free, partnership lane), and it runs against free paper accounts, including Tradovate Simulation, OANDA Practice, Bybit Testnet, and Bybit Spot Testnet, if you'd rather wire up your agent and watch it work before risking a cent anywhere. The rest of this guide walks through Tradovate Simulation as the example venue, since it's free and paper-only end to end, but the same tools work the same way once you link KRAKEN or CRYPTO instead. It shows what the tools do, how the safety model protects you, and what a first order looks like. See /mcp/ for the product overview, or keep reading for the walkthrough.

Start with setup

Before anything else, have your agent call setup. It's a read-only account overview: which exchanges you can actually trade right now (your subscriptions plus your token's scope), the per-exchange facts this guide covers below (symbol format, supported order types, whether brackets or a manual priceRef are needed), and your hooks, each with whatever exchange is already linked to it. Everything entry, command, and alert need to run, in one call.

The main tool: entry

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

• hook_id, and exchange only if that hook links to more than one exchange: entry trades using credentials you already linked to a hook at /account/setup/ -- no exchange key, password, or secret is ever typed into the chat. Check the hooks (or setup) tool for your hook ids and what each is linked to. This guide's walkthrough uses a hook linked to TRADOVATESIM.
• symbol, side, and quantity. Quantity can be a plain number or a percentage of your balance, like 50%. If you're copying a symbol straight off a TradingView chart it'll be shaped like KRAKEN:XBTUSD -- Autoview wants the bare exchange-native symbol and, if you paste the TradingView form, tells you exactly how to convert it rather than a generic rejection.
• type: market, limit, post_only, ioc, fok, stop, or stop_limit -- but not every exchange supports every type. setup returns the exact list for whatever you've linked; entry rejects an unsupported type up front rather than passing it to the broker. Tradovate Simulation, this walkthrough's own venue, has no post_only (Tradovate has no post-only time-in-force); Kraken has no ioc or fok; OANDA Practice supports only market and 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 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. Pass the trace id from entry to read one order's events, or omit it to list your account's recent events instead, newest first -- optionally narrowed to one hook or one webhook delivery with hook_id and canonical_id. Omitting trace is also the only way to see an order a TradingView alert fired directly at your webhook, since it never went through entry and has no trace.

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, command, or alert 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.

Two ways to trade: entry vs. a reusable alert

entry is for right now: it fires one order immediately, as a dry run or, with live set, for real. Sometimes you want the opposite -- something that keeps working after this conversation ends, the same way a TradingView alert does. That's what alert is for.

alert fuses two smaller tools into the shape TradingView's own create_alert(webhook, message, expiration, resolution) needs: command (which turns the same order fields entry takes into the message text TradingView's alert box expects, without placing anything) and hooks (which returns the webhook URL for a hook_id). It also closes two traps neither tool alone catches: TradingView itself defaults a new alert's expiration to 30 days out, silently stopping it a month later, so alert defaults to a year instead; and it warns you never to put a hook's ?key= in the alert's message field, since TradingView's own alert log hands that message back to anything reading it later -- the key belongs only in the webhook URL.

Ask your agent to build the alert instead of placing the order, and it hands back something you paste straight into create_alert. From there Autoview executes it the normal webhook way, the same existing path, with no agent needed once it's wired up.

One field alert hands back as-is: symbol. It comes back in Autoview's exchange-native shape (XBTUSD on Kraken, MESU25 on Tradovate), the same value you passed entry or command -- but TradingView's create_alert wants its own EXCHANGE:TICKER form (KRAKEN:XBTUSD). If your agent is talking to both Autoview and TradingView's MCP server in the same session, tell it to convert the symbol before calling create_alert; forwarding it straight through fails on TradingView's side with no hint that the shape is the problem.

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.
• An exchange linked to a hook. entry and alert trade using credentials you link once at /account/setup/ -- pick your exchange, enter its keys there, and Autoview keeps them off every later MCP call. This walkthrough uses a Tradovate Simulation account, but Kraken, Crypto.com, or any other supported exchange links the same way.
• 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 call -- or, if your MCP client can set a custom header (Claude Code, Cursor, and most non-browser clients do this automatically once configured), send it once as an Authorization: Bearer header instead and drop the argument entirely.

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.

Or connect without minting a token: OAuth

If your client supports adding a connector by URL, such as claude.ai's "Add custom connector," point it at https://api.autoview.com/mcp/ instead of generating a token by hand. The client discovers Autoview's OAuth metadata on its own, sends you to an Autoview login and consent screen, and mints the token behind the scenes once you approve.

An OAuth-issued token shows up at /account/tokens/ labeled OAuth: <client>. It stays dry-run on every exchange -- the consent screen has no live switch to offer -- so it's a safe way to let an agent explore setup, entry, and events before you decide to hand it anything live-enabled. To go live, generate a live-enabled token the normal way above and use that instead. Revoke works the same for an OAuth token as any other: from /account/tokens/, 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.

The endpoint is https://api.autoview.com/mcp/. A minimal request shape, once you have a token from the previous step:

POST /mcp/ HTTP/1.1
Host: api.autoview.com
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
Host: api.autoview.com
Mcp-Session-Id: <session-id>
Authorization: Bearer av_mcp_...
Content-Type: application/json

{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{
  "name":"entry","arguments":{
    "hook_id":"...",
    "symbol":"MESU25","side":"buy","type":"market","quantity":1,
    "live":false}}}

hook_id is one of your hooks from the hooks (or setup) tool, already linked to your Tradovate simulation credentials at /account/setup/ -- nothing exchange-specific travels on this call. Sending the token as an Authorization: Bearer header, as shown, means the token argument can be dropped entirely; pass it as an argument instead if your client can't set custom headers. 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 your hook_id, 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 beyond this walkthrough: live on TRADOVATESIM means a real fill on your paper account, since Tradovate through the MCP is simulation only today. Kraken and Crypto.com are different -- live on a hook linked to KRAKEN or CRYPTO places a real order on a funded account, the same as d=1 versus a live command on the webhook path. Kraken needs an active Autoview Kraken subscription; Crypto.com is free. Run through this guide on Tradovate Sim first if you want the rehearsal with zero risk, then link Kraken or Crypto.com at /account/setup/ and point the same entry and events calls at that hook when you're ready.

Where this is going

Paper-first is the safe on-ramp, not a ceiling. The same entry path already places real trades on Kraken and Crypto.com today, and already understands limit and stop orders, percentage sizing, and (on Tradovate Sim) attached brackets. OANDA, Bybit, and the rest of Autoview's other exchanges reach the MCP the same way, venue by venue, as each clears its own coverage pass. For now, wire up your agent, get comfortable reading the dry-run previews on a free paper venue -- through entry directly or through a reusable alert -- and move to a live exchange whenever you're ready.

Create your account