Skip to content

Autoview MCP server

com.autoview/mcpautoview.comstreamable-httpv0.119.4Scanned

Place and inspect orders on your own exchange accounts from an MCP-connected agent.

20 tools: 4 can delete or cancel things, 1 do something that can't be undone, 8 change things and 7 only read.

Tools: 4 delete, 1 irreversible, 8 write, 7 read.
  • Reads private data · 1
  • Reads text others write · 5
  • Can send data out · 1
  • 15 findings

Tools listed without sign-in. Remote posture

With Anlyon

4 tools here can delete or cancel things and 1 does something that can't be undone. Govern them.

  • Anlyon lists the tools and adopts none.
  • Each tool you adopt gets approvals and receipts.
  • Your agent never holds the key.
Govern this server →

A tool your agent calls directly is not routed through Anlyon and is not governed by it. Anlyon Radar only lists and labels, and these labels are the same either way.

What the Autoview MCP server can do

The Autoview MCP server is published by autoview.com, a domain the MCP Registry verified. It has 20 tools. It can delete or cancel things (4 tools: revoke_token, unlink, entry and paper_reset), do things that cannot be undone, such as sending, paying or publishing (send_feedback) and create or change data (8 tools: connect, link, command, explain_command and 4 more). 7 tools only read.

1 tool reads private data (feedback_status); 5 tools bring in text other people can write (entry, sandbox_run, sandbox_results and 2 more); 1 tool can send data out of your system (send_feedback). On its own it has all three parts of a prompt-injection exfiltration path: private data, text others write, and a way out.

The fixed checks matched 15 findings (credentials-mention, long-description and annotation-conflict). Each one comes with the text it matched.

Its remote endpoint lists its tools without sign-in, and its tools changed 10 times since Anlyon Radar first saw them.

Last scanned Nov 21, 2026, version 0.119.4.

Tools

Grouped by what each tool does, most consequential first. Open one for its reasons and full description; descriptions are the publisher's own words.

20 tools

Deletes or cancels 4Claude Code: deny
  • entryPlace an order on any exchange you have linked to a hook, right now — or manage existing orders/positions on `symbol` via `action` (cancel open orders, close open positions, or fla…Reads text others write3 findings

    Why it is in this group

    • Nothing in its name or description says what it does, so it is counted as a write.
    • The server marks it destructive (destructiveHint: true).

    What it can reach

    • untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.

    Findings

    • Info

      The description mentions "Credentials".

      Matched text

      description: "...canonical_id (or trace) a moment later. Credentials come from hook_id -- the credentials yo..."

      What this check looks for
    • Info

      The input schema at properties.hook_id.description mentions "credentials".

      Matched text

      inputSchema.properties.hook_id.description: "use the credentials already linked to this hook (see the `h..."

      What this check looks for
    • Info

      The description is 8,516 characters long, over the 2,000 this check looks for.

      Matched text

      description ends: "...nd the token with hook_id for a hook linked to that exchange, or use sandbox_run."

      What this check looks for
    Description, as the server wrote it
    Place an order on any exchange you have linked to a hook, right now — or manage existing orders/positions on `symbol` via `action` (cancel open orders, close open positions, or flat/liquidate everything — Tradovate only). You fill structured order fields (symbol, side, quantity, type, price, trigger) — Autoview assembles the order for you. Or pass alert: the same command text a webhook body carries, which reaches the engine unchanged, so every syntax key a webhook supports is supported here. Dry-run by default: a bare call returns the parsed order without placing it; set live:true to place a real order. On a paid exchange without an active Autoview subscription, live:true is silently downgraded to a dry-run — the response then carries dry_run_forced:true and a dry_run_reason explaining why (see the `setup` tool for which exchanges this applies to, and where to subscribe). The order is relayed to the exchange asynchronously: this returns { queued, trace, canonical_id } immediately, not the fill. For a dry-run (the default), entry waits up to ~10s for the exchange's own reply and returns it as dry_run_events when it arrives in time — otherwise dry_run_pending:true, and you can poll the `events` tool with canonical_id (or trace) a moment later. Credentials come from hook_id -- the credentials you already linked to one of your hooks (see the `hooks` or `setup` tool) -- so no exchange secret is passed with the order. exchange is optional when that hook links to exactly one exchange; pass it explicitly if the hook links to more than one. If you don't have credentials linked yet, use the `command` tool to check an order's shape without a hook. Live limits: a live:true order (not cancel/close/flat) must fit this token's user-set caps AND, once your user has set them, the account caps (they cover every agent token on the account together; with none set, the token's caps alone apply), and any limits your user set for one exchange or one symbol on it, which can only be tighter; read them all with `live_limits`. It must be a limit order with price and a plain number quantity, in a USD or USD-stablecoin quoted market; the order's USD notional, the higher of quantity x limit price and quantity x trigger price (and on a sell, quantity x current bid from the exchange's quote when that is higher), must be at most the token's max order size (and the account's, if set), and today's totals (UTC day, counted at dispatch; per token, and for the whole account if an account daily limit is set) at most those daily limits. Refusal codes, each with fix steps: agent_trading_paused (your user paused all agent trading on the account; cancel/close/flat still work), agent_token_paused (your user paused this one token; cancel/close/flat still work), caps_not_set, caps_unavailable, cap_max_order_exceeded, cap_account_max_order_exceeded, cap_daily_limit_exceeded, cap_account_daily_limit_exceeded, cap_venue_max_order_exceeded, cap_venue_daily_limit_exceeded, cap_venue_daily_orders_exceeded (an exchange limit), cap_symbol_max_order_exceeded, cap_symbol_daily_limit_exceeded, cap_symbol_daily_orders_exceeded (a limit on one symbol on that exchange), cap_order_rate_exceeded (this token's limit on live orders per rolling minute, if your user set one; wait retry_after_s seconds), cap_limit_price_required, cap_quantity_unsupported, cap_quote_unsupported, cap_market_unsupported. Only your user can set or raise the caps, or pause and resume agent trading, at /account/tokens/. Requires your Autoview account token, except for a paper fill. No token? On BINANCE, BINANCEFUTURES, BINANCEUS, BITFINEX, BITGET, BITGETMIX, BITGETMIXCOPY, BYBIT, BYBITCOPY, BYBITEU, BYBITSPOT, COINBASE, CRYPTO, DERIBIT, GATE, GATEFUTURES, GEMINI, HUOBI, HUOBIFUTURES, HUOBILINEAR, HUOBISWAP, KRAKEN, KRAKENFUTURES, KUCOIN, KUCOINFUTURES, KUCOINFUTURESCOPY, OKX, OKXEEA, OKXUS, leave out token and hook_id, pass exchange and one order (structured, or one alert line with no & sections and no | or line breaks), and entry fills it on paper at the quote an Autoview zone reads from that venue's public market data: a buy at the ask, a sell at the bid, for a market order and for a limit order that crosses the quote (its limit price is echoed as limit_price). A limit order that does not cross the quote (a buy limit below the ask, a sell limit above the bid) is stored instead as an open paper order and returns { paper_order: true, order: { order_id, symbol, side, qty, limit_price, state: "open" }, cash, note }, moving neither cash nor the position; it fills at its limit price the first time a later quote crosses it, checked when paper_ledger reads that ledger or entry sends a paper order on that symbol to it (orders it filled come back as filled_orders). Cancel it with action cancel and order_id on the same ledger (paper_cancel: true; paper_order_unknown if that ledger has no such order, paper_order_not_open if it already filled or was cancelled). Every stored paper fill returns fill_id. An alert id= (your own order id, one word of up to 64 characters, or paper_sender_id_invalid) comes back as sender_id. On an account paper ledger (token, no hook_id) each fill also writes one entry of type paper_fill to the events tool, with canonical_id, fill_id and sender_id; the reply returns canonical_id, and a resting order uses its order_id as its canonical_id. A guest ledger writes no events. Nothing is sent to the exchange. The first fill opens a paper ledger for that exchange and returns paper_id, shown only once; pass it as paper_id on later no-token fills on the same exchange and each fill is recorded there; read it back with paper_ledger and that paper_id. It returns { paper_fill, exchange, fill, quote, stored, paper_id (first fill only), position: { symbol, qty (signed, negative is short), avg_price }, realized, cash }. cash is null until paper_reset sets a starting balance on the ledger; once set, a buy takes its notional from cash and a sell adds its notional, and a buy that… [2516 more characters not shown]

    Annotations the server declares

    • destructiveHint: true
    • openWorldHint: true
    • readOnlyHint: false
    • title: Place an order
  • paper_resetStart a paper ledger over with a starting balance: sets its cash to balance and clears its positions.No findings

    Why it is in this group

    • The name "paper_reset" says "reset": a word for a change.
    • The server marks it destructive (destructiveHint: true).
    Description, as the server wrote it
    Start a paper ledger over with a starting balance: sets its cash to balance and clears its positions. Earlier fills stay in its history. Nothing is sent to an exchange. After a reset, each paper fill on that ledger moves cash: a buy takes its notional (quantity x price) from cash and a sell adds its notional; a buy that costs more than the cash fills nothing and entry returns paper_insufficient_cash. Without a reset cash stays null and every order fills. Two forms. With paper_id (the id a no-token paper fill on entry returned) and no token: that one guest ledger. With your user's Autoview account token and no paper_id: the account's paper ledger on exchange, which its first token fill on entry opened or a paper_id claim moved onto the account (paper_ledger_none if there is none). A paper_id claimed by an account no longer works here without the token: reset that ledger with the token form. It also cancels the ledger's open paper limit orders, so none of them fills later against the new cash. Returns { paper_reset: true, exchange, cash, positions: [], cancelled_orders (how many open orders it cancelled), note }. cash is in the quote currency of the symbols traded, unconverted. A refusal returns { error, code }: paper_reset_invalid (exchange missing, or balance not a positive number up to 1000000000000), paper_id_unknown (no guest ledger has that paper_id), paper_id_other_exchange (the ledger is on another exchange), paper_reset_needs_id (neither paper_id nor a token), invalid_token, paper_exchange_out_of_scope (the token is not scoped for that exchange), paper_ledger_none (the account has no paper ledger on that exchange), paper_ledger_unavailable (nothing changed; try again shortly), paper_rate_limited (the paper_id form with no token is limited to 60 per hour from each connection, counted together with paper_ledger; wait until retry_at).

    Annotations the server declares

    • destructiveHint: true
    • idempotentHint: true
    • openWorldHint: false
    • readOnlyHint: false
    • title: Reset a paper ledger
  • revoke_tokenRevoke the token this call is made with, so it stops working at once: every later call with it is refused.No findings

    Why it is in this group

    • The name "revoke_token" says "revoke": a word for removing or ending something.
    • The server marks it destructive (destructiveHint: true).
    Description, as the server wrote it
    Revoke the token this call is made with, so it stops working at once: every later call with it is refused. It only ever revokes the calling token (there is no target to pass), never another token of the account. Already revoked or expired counts as done (ok, already_revoked:true), not as an error. Needs the token's "Allow revoke and unlink" permission, which is off until your user ticks it at /account/tokens/. Requires your Autoview account token.

    Annotations the server declares

    • destructiveHint: true
    • idempotentHint: true
    • openWorldHint: false
    • readOnlyHint: false
    • title: Revoke this token
Can't be undone 1Claude Code: ask
  • send_feedbackSend your user's feedback to the Autoview team: a feature request, a bug report, a question, or anything else.Reads text others writeCan send data outNo findings

    Why it is in this group

    • The name "send_feedback" says "send": a word for sending, and what is sent cannot be taken back.

    What it can reach

    • untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.
    • outboundThe name "send_feedback" says "send": it sends or publishes something to other people.
    Description, as the server wrote it
    Send your user's feedback to the Autoview team: a feature request, a bug report, a question, or anything else. Works with no account and no token (as a guest), or with your user's token. Each message is saved for a person to review before it goes to the team; there is no set response time. With a token, the account is attached on our side from the token, so do not add it. Never put passwords, API keys or other secrets in message. If your user wants an answer, put a way to reach them in contact (for example an email address), or with a token set contact to true to use the address on the account. Show your user the message and get their go-ahead before sending. message is up to 4000 characters. Limit: 2 per hour for each account, or for each guest. Returns { received, id, status, guest, remaining_this_hour, note }; pass note to your user. A refusal returns { error, code, fix }: bad_kind, message_empty, message_too_long, contact_too_long, invalid_token, feedback_rate_limited (with retry_at), feedback_unavailable, feedback_store_failed. Do what fix says.

    Annotations the server declares

    • destructiveHint: false
    • idempotentHint: false
    • openWorldHint: true
    • readOnlyHint: false
    • title: Send feedback to the Autoview team
Changes things 8Claude Code: ask
  • alertBuild everything TradingView's create_alert(webhook, message, expiration, resolution) needs, in one call: fuses `command` (the message) and `hooks` (the webhook URL for hook_id), a…No findings

    Why it is in this group

    • Nothing in its name or description says what it does, so it is counted as a write.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
    Description, as the server wrote it
    Build everything TradingView's create_alert(webhook, message, expiration, resolution) needs, in one call: fuses `command` (the message) and `hooks` (the webhook URL for hook_id), and fills in the expiration (default 1 year out -- TradingView itself defaults to only 30 days, which silently stops the alert) and resolution (default "1") TradingView also needs. The order is validated against the exchange(s) hook_id is actually linked to and rejected if it could never fire there. Returns warnings you should read, including never putting the hook's key in the message field and a fan-out warning when the hook links more than one exchange. Pass the alert field instead of the structured fields to use raw webhook command text with any key a webhook accepts. Dry-run by default like `command`; set live:true to build a command that trades for real once the alert fires. For any other sender, `command` + `hooks` give the same message and webhook URL; expiration and resolution are TradingView settings only. Requires your Autoview account token.

    Annotations the server declares

    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: false
    • readOnlyHint: true
    • title: Build a TradingView alert
  • commandBuild an Autoview alert command string from structured order fields (symbol, side, quantity, type, price, trigger), or from ONE line of the Autoview trade language (line, e.g.No findings

    Why it is in this group

    • Nothing in its name or description says what it does, so it is counted as a write.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
    Description, as the server wrote it
    Build an Autoview alert command string from structured order fields (symbol, side, quantity, type, price, trigger), or from ONE line of the Autoview trade language (line, e.g. "buy(BTCUSD, 0.2, -0.5%)"; grammar in catalog's language card), without placing an order. A line reply also carries echo, one plain sentence stating the resolved order: confirm the sentence, not the string: the output is the alert body any webhook sender POSTs to a hook URL (for TradingView, the value create_alert's `message` field carries). Also builds cancel/close/flat management commands via `action` (see entry's description). Dry-run by default: a bare call returns a preview command (appends d=1); set live:true to build a command that trades for real once the alert fires. Pass the alert field instead to check and return raw webhook command text with any key a webhook accepts. Prefer the `alert` tool if you also need the destination webhook, expiration, and resolution in one call. Requires your Autoview account token; live:true requires a live-scoped token. exchange is optional: pass any exchange id configured on Autoview (see the `catalog` tool; a bracket is refused if that exchange lists sl/tp as unsupported); omit exchange entirely to build a generic command routed by whichever exchange(s) the destination hook is linked to.

    Annotations the server declares

    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: false
    • readOnlyHint: true
    • title: Build an alert command
  • connectConnect any exchange configured on Autoview (see catalog) to your account: creates a webhook and links it to your already-saved credentials for that exchange, the same steps 2-4 th…1 finding

    Why it is in this group

    • Nothing in its name or description says what it does, so it is counted as a write.

    Findings

    • Info

      The description mentions "credentials".

      Matched text

      description: "...hook and links it to your already-saved credentials for that exchange, the same steps 2-4 t..."

      What this check looks for
    Description, as the server wrote it
    Connect any exchange configured on Autoview (see catalog) to your account: creates a webhook and links it to your already-saved credentials for that exchange, the same steps 2-4 the website's setup wizard runs. Safe to call more than once -- if a webhook is already linked, it reports connected:true and creates nothing new. If you have no credentials saved for this exchange yet, returns connect_url instead: open it in a browser to add them, then call connect again with the same exchange (for a paper/testnet exchange you can instead call link with its keys; real-money keys are browser-only). Connecting a real-money (non-paper) exchange requires a live-scoped token; any token can connect a paper/testnet exchange. Requires your Autoview account token.

    Annotations the server declares

    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: false
    • readOnlyHint: false
    • title: Connect an exchange
  • explain_commandExplain an existing Autoview command / alert message in plain English: what the engine will actually do with it on the named exchange (side, size, order type, price, brackets, acco…1 finding

    Why it is in this group

    • The name "explain_command" says "explain": a word for reading.
    • The input takes a statement or command to run (input.command), which can change anything it can reach.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.

    Findings

    • Warn

      The server marks "explain_command" read-only (readOnlyHint: true), and its own name, description or input give the class "write".

      Matched text

      annotations: {"readOnlyHint":true,"destructiveHint":false,"idempotentHint":true,"openWorldHint":false}; The name "explain_command" says "explain": a word for reading.

      What this check looks for
    Description, as the server wrote it
    Explain an existing Autoview command / alert message in plain English: what the engine will actually do with it on the named exchange (side, size, order type, price, brackets, account, dry run), plus caveats where that exchange quietly downgrades or ignores a key, or where the engine refuses the line. For example, Alpaca, Binance, Binance Delivery, ByBit Copy, Capital.com, Charles Schwab, OANDA and Tradovate have no post-only order, so the engine refuses t=post there and sends nothing, because the order would go out as a plain limit order that can fill at once; send t=limit for a plain limit. Accepts the classic key=value form (several lines, | or & legs included) or a one-line v3 call like buy(BTCUSD, 0.1, -1%). Returns { explanation: string, lines: [{ line, text, caveats: [{ text }], venue }] } or { error }. Read-only: it parses text only, never reads an account, a key, or sends anything. Describes, never recommends. No token, no account: works for a guest. To see a simulated fill beside the explanation, use sandbox_run.

    Annotations the server declares

    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: false
    • readOnlyHint: true
    • title: Explain a command
  • paper_ledgerRead a paper ledger back: its open positions, cash and the last fills, newest first.2 findings

    Why it is in this group

    • The description's first verb is "read": a word for reading.
    • The server marks it as not read-only (readOnlyHint: false).

    Findings

    • Info

      The description is 2,802 characters long, over the 2,000 this check looks for.

      Matched text

      description ends: "...at exchange, so it is kept, the guest ledger is not merged, and nothing changed)."

      What this check looks for
    • Warn

      The server marks "paper_ledger" as not read-only (readOnlyHint: false), and its words say it reads.

      Matched text

      annotations: {"readOnlyHint":false,"destructiveHint":false,"idempotentHint":true,"openWorldHint":false}; The description's first verb is "read": a word for reading.

      What this check looks for
    Description, as the server wrote it
    Read a paper ledger back: its open positions, cash and the last fills, newest first. Nothing is sent to an exchange. Three forms. With paper_id (the id a no-token paper fill on entry returned) and no token: that one guest ledger, returned as { paper_ledger: true, exchange, cash, positions: [{ symbol, qty, avg_price, mark, mark_side, quote_at, unrealised_pnl }], fills: [{ symbol, side, qty, price, notional, bid, ask, quote_at, at }], more_fills, orders, note }. orders lists the ledger's newest paper limit orders, any state: [{ order_id, symbol, side, qty, limit_price, state (open, filled or cancelled), at, closed_at }]. Before it answers, the read asks the current quote for each symbol with an open order and fills each open order that quote crosses, at its limit price. Each position is marked at the current quote on its symbol: mark is the bid for a long and the ask for a short (mark_side says which), quote_at is when the quote was read, and unrealised_pnl is (mark - avg_price) x qty. Up to 10 symbols are quoted per ledger, each waiting up to 3 seconds; a position with no quote has mark, quote_at and unrealised_pnl null and a mark_reason (cap when the ledger holds more symbols than that, otherwise the quote's code, such as quote_timeout). With your user's Autoview account token and no paper_id: the account's own paper ledgers, one per exchange, as { paper_ledger: true, ledgers: [{ exchange, cash, positions, fills, more_fills }], note }; ledgers is empty when the account has none yet. With the token and a paper_id: that guest ledger moves onto the account (first claim wins; the reply carries claimed:true on the call that moved it) and is returned in the account form, ledgers holding just that one; this is the only form that writes, and once moved the paper_id no longer works without the token. qty is signed (negative is short); positions that are flat are left out; cash is null until a starting balance is set; amounts are in the symbol's quote currency. more_fills is true when older fills exist beyond limit. A refusal returns { error, code }: paper_id_unknown (no guest ledger has that paper_id), paper_id_other_exchange (exchange names another venue than the ledger's), paper_ledger_needs_id (neither paper_id nor a token), invalid_token, paper_exchange_out_of_scope (the token is not scoped for that exchange), paper_ledger_unavailable (try again shortly), paper_rate_limited (the paper_id form with no token is limited to 60 per hour from each connection, counted together with paper_reset; wait until retry_at), paper_id_claimed (with a token: another account already took that paper_id's ledger), paper_id_not_merged (with a token: the account already has its own paper ledger on that exchange, so it is kept, the guest ledger is not merged, and nothing changed).

    Annotations the server declares

    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: false
    • readOnlyHint: false
    • title: Read a paper ledger
  • pricingWhat going live on Autoview costs, per venue.No findings

    Why it is in this group

    • Nothing in its name or description says what it does, so it is counted as a write.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
    Description, as the server wrote it
    What going live on Autoview costs, per venue. No token, no account: read-only, from Autoview's published price list. Each live exchange is its own subscription (most are $39.99 a month or $399.99 a year); practice/demo venues are free, and a few venues are free live. Returns { currency: "USD", venues: [{ exchange, name, live_monthly, live_yearly, demo, note, free_practice_venue?, live_venue? }], unknown?: [{ input, code: "unknown_exchange", fix }], how_to_go_live, source }. live_monthly and live_yearly are dollars (live_yearly is null when there is no yearly plan); demo is true for a practice venue (no real money, $0). Omit exchanges to list every venue. A refusal returns { error, code, fix }: bad_exchanges, too_many_exchanges, unknown_exchange. Do what fix says.

    Annotations the server declares

    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: false
    • readOnlyHint: true
    • title: What going live costs
  • sandbox_runRun one alert through Autoview's Alert Sandbox and see exactly what Autoview would do with it: the parsed orders and a simulated fill for each.Reads text others write1 finding

    Why it is in this group

    • The name "sandbox_run" says "run": a word for a change.
    • The input takes a statement or command to run (input.command), which can change anything it can reach.

    What it can reach

    • untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.

    Findings

    • Info

      The description is 6,822 characters long, over the 2,000 this check looks for.

      Matched text

      description ends: "...net or demo account through Autoview (pricing lists them with demo: true, at $0)."

      What this check looks for
    Description, as the server wrote it
    Run one alert through Autoview's Alert Sandbox and see exactly what Autoview would do with it: the parsed orders and a simulated fill for each. No token, no account, no exchange key: simulation only, no real order is placed. Send the order one of two ways: command (alert text: the classic key=value form "e=kraken s=BTCUSD b=buy q=0.01" or a v3 line "buy(BTCUSD, 0.01)"), or order (structured: { "exchange": "oanda", "symbol": "EURUSD", "side": "buy", "qty": 1000 }). Not both. A limit order is { ..., "type": "limit", "limit_price": 50000 }. order takes only exchange, symbol, side, qty, type and limit_price: order.price is refused (order_bad_field), because the top-level price is a different thing, the market price you read, not a limit. To close, send command with c=position (for example "e=kraken s=XBTUSD c=position") and the same sandbox_id: it closes that sandbox_id's paper position on the symbol at market, a long by a sell at the bid and a short by a buy at the ask. Prices. Each fill is priced in this order and labelled with where the price came from (fill.origin): own_key (the user's own connected account; not available yet, coming), venue_ticker (the venue's free public ticker, e.g. Kraken, Coinbase, OKX, Bybit for crypto), reference_ticker (another venue's public ticker, today Kraken XBTUSD for BTC/USD, used when the sandbox has no price source for the venue in e=), caller (a price you pass in price), alert_fp (fp= in the alert, e.g. TradingView {{close}}). If Autoview has no price for the market (stocks, most forex, futures), read the price from your own user's data source and pass it as price (plus price_source and price_time); the fill is then labelled caller-supplied, never presented as Autoview's quote. Returns { sandbox: true, real_order_placed: false, notice, sandbox_id, webhook_url, compiled?, orders: [{ exchange, side, symbol, qty, type, order_price?, fill }], explanation?, next }. Fill shapes. A priced fill is { status: "filled", price, price_label, price_source, origin, origin_note, priced_at, price_age_ms, side_of_book?, limit?, price_warning?, caller_price_source?, caller_price_time? }. price_label is Autoview's short label for where the fill price came from, for example "Kraken XBTUSD best ask" (a venue fill at the ask) or "caller-supplied" (your price). price_source is the same label under its older name, kept for existing readers. The source and time you sent with a caller price are echoed in caller_price_source and caller_price_time. A market order, or a limit the book has reached (a buy limit at or above the ask, a sell limit at or below the bid; with a caller price, at or better than it), fills at the ask, bid or your price, never at the limit. price_warning is set when the price was more than 15 minutes old at receipt (for example "The caller price is 5h 2m old"): the fill still used it, so read a fresh price if you want a current fill. A limit the price has not reached is { status: "not_filled", price: null, reference_price, limit, price_label, side_of_book?, origin, origin_note, note, fix }: nothing filled and the sandbox never fills it later; do not pass price again, read fix. An unpriced fill is { status: "no_price", price: null, note, website_note?, price_error? }: price_error is { code, market, message, fix: [steps] }; follow the fix steps and call again. A c=position close with no open position on that symbol for this sandbox_id is { status: "nothing_to_close", price: null, note }: nothing was filled and there is nothing to fix. price_error codes (in fill.price_error, on a no_price fill): no_live_source (Autoview has no live price for this market or venue; pass price, or set e= to a priced crypto venue), venue_read_failed (the venue's public ticker did not answer; retry, or pass price), price_ambiguous (price was sent with an alert that has more than one symbol; send one symbol per call). bad_price_param is the website's code for malformed price fields; it arrives as the refusal bad_price with price_error beside it. Refusal codes (the whole call returns { error, code, fix }; do what fix says): command_required, command_and_order, bad_v3_line, bad_sandbox_id, order_missing_field, order_bad_field, bad_price, bad_price_source, bad_price_time, price_fields_without_price, sandbox_refused, sandbox_rate_limited, sandbox_bad_answer, sandbox_unreachable, sandbox_timeout, internal_error. sandbox_id is minted when you omit it; pass it back to add more alerts to the same sandbox, and read them with sandbox_results. Any webhook sender can also POST alerts to webhook_url. Call pricing to see what going live costs. Replaying past prices. To test a strategy on history, send one sandbox_run call per signal, oldest first. Set price to the price at that bar from your own data, price_source to where the data came from, and price_time to the bar's time. A past price_time is accepted; one more than a day in the future is refused (bad_price_time). Pass the sandbox_id from the first call on every later call, so all the fills land in one sandbox. Each fill uses your price as sent: fill.origin is caller, origin_note says the source and time are yours and not Autoview's quote, caller_price_time echoes the time you sent, and price_age_ms is how long before receipt that time was. A price more than 15 minutes old also gets price_warning, and the fill still counts. A limit your price has not reached comes back not_filled, and a later call does not fill it. Then call sandbox_results with the same sandbox_id: its book works out the position and realized P&L from the fills in the order they arrived, not by price_time. Every call counts toward the sandbox alert limits; on sandbox_rate_limited, do what fix says. Fill model (every fill carries it as fill_model): each order fills at one snapshot price taken when the alert arrives, either the venue's public ticker (its best ask for a buy and best bid for a sell when the venue gives them, otherwise its last trade) or a price you supply (… [822 more characters not shown]

    Annotations the server declares

    • destructiveHint: false
    • idempotentHint: false
    • openWorldHint: true
    • readOnlyHint: false
    • title: Run an alert in the sandbox
Only reads 7Show 7 read-only tools
  • catalogList every exchange configured on Autoview, filterable by paper (testnet/practice/sim, no real money), free (no Autoview subscription required), and name.2 findings

    Why it is in this group

    • The description's first verb is "list": a word for reading.

    Findings

    • Info

      The description mentions "credentials".

      Matched text

      description: "...ry, command, alert and connect once its credentials are linked to one of your hooks (the ex..."

      What this check looks for
    • Info

      The input schema at properties.exchange.description mentions "credential".

      Matched text

      inputSchema.properties.exchange.description: "...ACTICE" or "oanda-practice") to get its credential schema and facts instead of the list; p..."

      What this check looks for
    Description, as the server wrote it
    List every exchange configured on Autoview, filterable by paper (testnet/practice/sim, no real money), free (no Autoview subscription required), and name. Every listed exchange works with entry, command, alert and connect once its credentials are linked to one of your hooks (the exchange itself validates the order); linkable ones also take paper keys via link -- see connect_url to add credentials for one. Pass exchange (any spelling of its id, e.g. "OANDAPRACTICE") to get that one exchange in detail instead of the list: credentials is a JSON Schema whose property keys are exactly the keys link takes (titles are the exchange's own labels, required lists the ones it needs), plus linkable and unsupported_parameters (command parameters the exchange rejects, e.g. sl/tp; an attached bracket using one is refused up front). The list reply also carries language: the card for the one-line Autoview trade language that command({ line }) accepts. Requires your Autoview account token.

    Annotations the server declares

    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: false
    • readOnlyHint: true
    • title: Browse the exchange catalog
  • eventsRead what your orders did.No findings

    Why it is in this group

    • The description's first verb is "read": a word for reading.
    Description, as the server wrote it
    Read what your orders did. Pass trace (the id entry or command's caller received) to read one order's events; omit trace to list your account's recent events instead, newest first, optionally narrowed by hook_id and/or canonical_id — this is the only way to see an order any webhook sender (TradingView, a script, another platform) fired directly, since it never went through entry and has no trace. Requires your Autoview account token. Poll this a moment after an order if the events are not there yet — the exchange reports back out-of-band.

    Annotations the server declares

    • destructiveHint: false
    • openWorldHint: false
    • readOnlyHint: true
    • title: Read order events
  • feedback_statusRead where one send_feedback message stands: pending (waiting for a person to review it), approved (passed on to the Autoview team) or declined (reviewed and not passed on), with r…Reads private dataReads text others writeNo findings

    Why it is in this group

    • The name "feedback_status" says "status": a word for reading.

    What it can reach

    • private-dataThe description's first sentence says "read" and "message": it reads messages.
    • untrusted-inputThe description's first sentence says "read" and "message": it reads messages, which other people can write.
    Description, as the server wrote it
    Read where one send_feedback message stands: pending (waiting for a person to review it), approved (passed on to the Autoview team) or declined (reviewed and not passed on), with received_at. Pass the id send_feedback returned and the same account token it was sent with. Only the status comes back, never the message or contact. Feedback sent without a token has no status to read. Returns { id, status, received_at, note }. A refusal returns { error, code, fix }: bad_id, not_found (no such id for this account; the same answer for an id that belongs to someone else), invalid_token, feedback_unavailable. Do what fix says.

    Annotations the server declares

    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: false
    • readOnlyHint: true
    • title: Read a feedback message's status
  • hooksList your Autoview webhook URLs: the address any webhook sender POSTs an alert to (a script or cron job, n8n, Zapier, your own server, or a TradingView alert's webhook field).No findings

    Why it is in this group

    • The description's first verb is "list": a word for reading.
    Description, as the server wrote it
    List your Autoview webhook URLs: the address any webhook sender POSTs an alert to (a script or cron job, n8n, Zapier, your own server, or a TradingView alert's webhook field). The body is the command text from `command`, sent as plain text, a JSON string, or JSON {"alert": "..."} (form posts are refused). Each hook already knows which exchange(s) it is linked to; there is nothing further to configure on the Autoview side. Pair with the `command` tool (or use `alert` to build both at once). Requires your Autoview account token. The returned URL is itself a bearer secret for unattended trading — treat it like a password; rotate a hook's key from /account/hooks/ on the Autoview site if it leaks.

    Annotations the server declares

    • destructiveHint: false
    • openWorldHint: false
    • readOnlyHint: true
    • title: List webhook URLs
  • live_limitsRead this token's live limits: the max order size and daily limit (USD notional: quantity x limit price, or quantity x trigger price when that is higher, or on a sell quantity x cu…No findings

    Why it is in this group

    • The description's first verb is "read": a word for reading.
    Description, as the server wrote it
    Read this token's live limits: the max order size and daily limit (USD notional: quantity x limit price, or quantity x trigger price when that is higher, or on a sell quantity x current bid when that is higher) your user set for this token, the account caps that cover every agent token on the account together (the hard outer limit once set; account.set is false when your user has not set them, and then the token's own caps alone apply), any tighter limits your user set for one exchange or one symbol on it (venue_caps, with today's use there), the most live orders this token may place in any rolling minute (max_orders_per_minute; null = no rate limit), how much of each is used today, and whether this token can place a live entry order right now. Read-only: an agent cannot set or raise these; only the user can, at /account/tokens/ (set_at). The day is the UTC calendar day (resets_at). Returns { live, max_order_usd, daily_limit_usd, used_today_usd, remaining_today_usd, account: { set, max_order_usd, daily_limit_usd, used_today_usd, remaining_today_usd }, effective_max_order_usd, effective_remaining_today_usd, venue_caps, max_orders_per_minute, agent_trading_paused, paused_at, token_paused, token_paused_at, day, resets_at, unit, set_at, can_place_live, code?, reason? }. agent_trading_paused true means your user has paused all agent trading on the account (code agent_trading_paused); only your user can turn it off. token_paused true means your user has paused this token (code agent_token_paused); only your user can turn it off. Tell your user these numbers before going live. Requires your Autoview account token.

    Annotations the server declares

    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: false
    • readOnlyHint: true
    • title: Read this token's live limits
  • sandbox_resultsRead the simulated fills stored for a sandbox_id (from sandbox_run, or any Alert Sandbox webhook id), newest first.Reads text others write1 finding

    Why it is in this group

    • The description's first verb is "read": a word for reading.

    What it can reach

    • untrusted-inputThe server marks it openWorldHint: true: it reaches things outside the server's own data.

    Findings

    • Info

      The description is 2,892 characters long, over the 2,000 this check looks for.

      Matched text

      description ends: "...net or demo account through Autoview (pricing lists them with demo: true, at $0)."

      What this check looks for
    Description, as the server wrote it
    Read the simulated fills stored for a sandbox_id (from sandbox_run, or any Alert Sandbox webhook id), newest first. No token, no account, no key: simulation only, no real order was placed. Returns { sandbox: true, real_order_placed: false, notice, sandbox_id, alerts: [{ received_at, seq?, orders?: [same shape as sandbox_run orders, including fill.status (filled, not_filled, no_price or nothing_to_close), fill.origin, fill.price_label, fill.price_warning and fill.price_error], error? }], more, book, next_step } where alerts lists the newest 10 and more is true when older alerts exist beyond them. book = { positions: [{ exchange, symbol, net_qty, avg_entry, realized_pnl, last_fill_price, fills }], unvalued: [{ exchange, symbol, count }], unvalued_count, complete, method, note } is worked out on this call from up to 1000 stored alerts (an id with no account holds fewer, so it covers the whole store): average-cost, each market starting flat at its oldest fill read, no cash and no fees; net_qty is negative for a short and avg_entry is null when flat. Fills with no price or a percent qty are counted in unvalued and never valued; complete is false when older fills exist beyond the read. next_step = { market, practice_venue, practice_venue_name, same_venue, free, connect_url, text } names the free testnet or demo venue for the newest order's market and the page where your user connects it; practice_venue is null when Autoview has no match, and free is false when the only demo is not free to open. Pass text to your user as the next step. A refusal returns { error, code, fix }: bad_sandbox_id (malformed id), sandbox_refused (e.g. the id belongs to an account), sandbox_rate_limited, sandbox_bad_answer, sandbox_unreachable, sandbox_timeout, internal_error. Do what fix says. Fill model (every fill carries it as fill_model): each order fills at one snapshot price taken when the alert arrives, either the venue's public ticker (its best ask for a buy and best bid for a sell when the venue gives them, otherwise its last trade) or a price you supply (price, or fp= in the alert). A market order fills at that price. A marketable limit (a buy limit at or above it, a sell limit at or below it) fills at that price, never at the limit; any other limit stays open as not_filled and never fills later. The sandbox does not model order-book depth, slippage, latency or partial fills, and a caller price or last trade carries no spread, so live results will differ. fill.book_size is the size the venue's public ticker showed at that best ask or bid when the price was read, passed on as stored; it is not depth, it does not change the fill, and it is null when the price came with no size (a caller price, fp=, or a venue whose ticker gives none). For live-like execution, use the venue's own testnet or demo account through Autoview (pricing lists them with demo: true, at $0).

    Annotations the server declares

    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: true
    • readOnlyHint: true
    • title: Read sandbox fills
  • setupRead this FIRST.1 finding

    Why it is in this group

    • The description's first verb is "read": a word for reading.

    Findings

    • Info

      The description mentions "credential".

      Matched text

      description: "...meters), its setup_url and its required credential labels (credentials)), and your hooks w..."

      What this check looks for
    Description, as the server wrote it
    Read this FIRST. Returns your account overview: token scopes (live/exchange), which exchanges your token can call at all (callable), which of those allow a real live order right now vs. force a dry-run for lack of an active subscription (live_allowed/dry_run_forced, with upgrade_url when forced), per-exchange facts (id, whether it is free, whether it is a paper/no-real-money venue, whether the `link` tool accepts it (linkable), the parameters its integration lists as unsupported (unsupported_parameters), its setup_url and its required credential labels (credentials)), and your hooks with their linked exchanges. If no hook is linked to any exchange yet, recommended_first_exchange points at a free paper venue to start with. failing_hooks flags any hook whose last several alerts all failed with the SAME error (a stuck webhook loop). Requires your Autoview account token.

    Annotations the server declares

    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: false
    • readOnlyHint: true
    • title: Account overview

This is not a safety rating, and no finding is not a safety guarantee. The groups and findings come from fixed checks of the tool definitions the server returned on the date shown, not from its code or what it does when called. How the checks work.

Exfil surface

Which tools read private data, which read text someone else can write, and which can send data out. One of each is a path a prompt injection can use.

5 paths in this server alone from private data, through text someone else wrote, to a way out. Denying 1 outbound tool breaks every one.

Reads private data1
Reads files, mail, messages, databases, secrets, calendars or repositories.
Reads text others write5
Brings in text someone else can write: web pages, inbound email, messages, issues and comments.
Can send data out1
Can carry data to people or systems: it sends, posts or publishes, or takes a recipient, channel or URL.
deny to break every path
{
  "permissions": {
    "deny": [
      "mcp__autoview__send_feedback"
    ]
  }
}

Other servers in the same agent add their own tools to these paths. Audit your whole setup to see them together.

Remote posture

What anyone on the internet sees at the remote endpoint: an anonymous initialize and tools/list, and the public OAuth metadata.

Tools listed without sign-in

Looked at Nov 20, 2026, 18:34 UTC, unchanged since Nov 13, 2026. No credentials were sent and no tool was called. What is looked at.

Reachable
yes
HTTP status of an anonymous initialize
200
tools/list served without credentials
yes
Tools that change things, listed without credentials
13
Protocol version
2025-06-18
WWW-Authenticate on 401
not observed
resource_metadata in WWW-Authenticate
not observed
RFC 9728 protected resource metadata
https://api.autoview.com/.well-known/oauth-protected-resource/mcp
Authorization servers
https://api.autoview.com/
Legacy HTTP+SSE transport
no
Dynamic client registration
yes
Client ID metadata documents
no
  • HighThe whole server

    The endpoint served tools/list without credentials, and the list has 13 tools that change things (4 destructive, 1 irreversible, 8 write). Whether a call also works without credentials was not tested: tools are never called.

    Matched text

    https://api.autoview.com/mcp/: tools/list returned 20 tools to an anonymous client, including revoke_token (destructive), unlink (destructive), entry (destructive), paper_reset (destructive), send_feedback (irreversible) and 8 more

    What this check looks for

Posture changes

  1. Nov 13, 2026
    • Tools that change things, listed without credentials: 11 to 13
  2. Nov 6, 2026
    • Tools that change things, listed without credentials: 8 to 11
  3. Oct 29, 2026
    • Tools that change things, listed without credentials: 5 to 8

Findings

Matches of fixed checks, with the text they matched.

2 warn13 info
  • The server marks "explain_command" read-only (readOnlyHint: true), and its own name, description or input give the class "write".

    Matched text

    annotations: {"readOnlyHint":true,"destructiveHint":false,"idempotentHint":true,"openWorldHint":false}; The name "explain_command" says "explain": a word for reading.

    What this check looks for
  • The server marks "paper_ledger" as not read-only (readOnlyHint: false), and its words say it reads.

    Matched text

    annotations: {"readOnlyHint":false,"destructiveHint":false,"idempotentHint":true,"openWorldHint":false}; The description's first verb is "read": a word for reading.

    What this check looks for
  • Infosetup

    The description mentions "credential".

    Matched text

    description: "...meters), its setup_url and its required credential labels (credentials)), and your hooks w..."

    What this check looks for
  • The description mentions "credentials".

    Matched text

    description: "...hook and links it to your already-saved credentials for that exchange, the same steps 2-4 t..."

    What this check looks for
  • Infolink

    The description mentions "credentials".

    Matched text

    description: "...iew.com in a browser (see connect). The credentials object uses named keys (public, private..."

    What this check looks for
  • Infolink

    The input schema at properties.credentials.description mentions "credentials".

    Matched text

    inputSchema.properties.credentials.description: "...e fields the chosen exchange takes. The credentials object uses named keys (public, private..."

    What this check looks for
Show 9 more findings
  • Infolink

    The input schema at required[1] mentions "credentials".

    Matched text

    inputSchema.required[1]: "credentials"

    What this check looks for
  • The description mentions "credentials".

    Matched text

    description: "...ry, command, alert and connect once its credentials are linked to one of your hooks (the ex..."

    What this check looks for
  • The input schema at properties.exchange.description mentions "credential".

    Matched text

    inputSchema.properties.exchange.description: "...ACTICE" or "oanda-practice") to get its credential schema and facts instead of the list; p..."

    What this check looks for
  • Infoentry

    The description mentions "Credentials".

    Matched text

    description: "...canonical_id (or trace) a moment later. Credentials come from hook_id -- the credentials yo..."

    What this check looks for
  • Infoentry

    The input schema at properties.hook_id.description mentions "credentials".

    Matched text

    inputSchema.properties.hook_id.description: "use the credentials already linked to this hook (see the `h..."

    What this check looks for
  • Infoentry

    The description is 8,516 characters long, over the 2,000 this check looks for.

    Matched text

    description ends: "...nd the token with hook_id for a hook linked to that exchange, or use sandbox_run."

    What this check looks for
  • The description is 6,822 characters long, over the 2,000 this check looks for.

    Matched text

    description ends: "...net or demo account through Autoview (pricing lists them with demo: true, at $0)."

    What this check looks for
  • The description is 2,892 characters long, over the 2,000 this check looks for.

    Matched text

    description ends: "...net or demo account through Autoview (pricing lists them with demo: true, at $0)."

    What this check looks for
  • The description is 2,802 characters long, over the 2,000 this check looks for.

    Matched text

    description ends: "...at exchange, so it is kept, the guest ledger is not merged, and nothing changed)."

    What this check looks for

History

Changes to its tool definitions and to its remote endpoint, newest first.

  1. Tools2 changed.~2 changedView diff
    • Changed:entryDeletes or cancelsdescription
    • Changed:sandbox_runChanges thingsdescription
  2. Tools1 changed.~1 changedView diff
    • Changed:entryDeletes or cancelsdescription
  3. Tools4 changed.~4 changedView diff
    • Changed:alertChanges thingsinputSchema
    • Changed:commandChanges thingsinputSchema
    • Changed:connectChanges thingsinputSchema
    • Changed:entryDeletes or cancelsdescriptioninputSchema
  4. PostureRemote posture changed. Tools that change things, listed without credentials: 11 -> 13.View diff
    • Tools that change things, listed without credentials: 11 to 13
  5. Tools3 changed.~3 changedView diff
  6. Tools1 added, 6 changed.+1 added~6 changedView diff
  7. Tools2 added, 5 changed.+2 added~5 changedView diff
  8. PostureRemote posture changed. Tools that change things, listed without credentials: 8 -> 11.View diff
    • Tools that change things, listed without credentials: 8 to 11
  9. Tools2 added.+2 addedView diff
  10. Tools3 changed.~3 changedView diff
    • Changed:alertChanges thingsdescriptioninputSchema
    • Changed:commandChanges thingsdescriptioninputSchema
    • Changed:entryDeletes or cancelsdescriptioninputSchema

Install

Pinned to version 0.119.4. Values in angle brackets are yours to fill in.

claude mcp add --transport http autoview https://api.autoview.com/mcp/
claude mcp add --transport http autoview https://api.autoview.com/mcp/

Run in a terminal.

Claude Code permissions

Allow the reads, ask before a change or a way out, deny the deletes. Paste into .claude/settings.json.

.claude/settings.json
{
  "permissions": {
    "allow": [
      "mcp__autoview__setup",
      "mcp__autoview__catalog",
      "mcp__autoview__events",
      "mcp__autoview__hooks",
      "mcp__autoview__sandbox_results",
      "mcp__autoview__live_limits",
      "mcp__autoview__feedback_status"
    ],
    "ask": [
      "mcp__autoview__connect",
      "mcp__autoview__link",
      "mcp__autoview__command",
      "mcp__autoview__explain_command",
      "mcp__autoview__sandbox_run",
      "mcp__autoview__paper_ledger",
      "mcp__autoview__pricing",
      "mcp__autoview__alert",
      "mcp__autoview__send_feedback"
    ],
    "deny": [
      "mcp__autoview__revoke_token",
      "mcp__autoview__unlink",
      "mcp__autoview__entry",
      "mcp__autoview__paper_reset"
    ]
  }
}

Tools that only read are allowed, tools that change things ask first, tools that delete or cancel are denied. A read that can send data out (it takes a URL, say) asks first too. It assumes the server is installed as autoview. Review it before you use it.

Capability tags behind 5 rules
  • mcp__autoview__entry untrusted-input
  • mcp__autoview__sandbox_run untrusted-input
  • mcp__autoview__sandbox_results untrusted-input
  • mcp__autoview__send_feedback untrusted-input, outbound
  • mcp__autoview__feedback_status private-data, untrusted-input

Pin

Keep the decision: fail CI when the tools change, follow every change, or show a badge.

Pin in CI

Fail a build when the tools you reviewed are not the tools the server serves today.

curl -s "https://radar.anlyon.com/api/v1/servers/com.autoview/mcp/verify?hash=1eab142261b586b72f5d3c9c9889f10ffd40dfbbcd09375dd2a025cad4c261ce" | jq -e '.changed == false'

Pinned hash 1eab142261b5, from Nov 21, 2026, 08:17 UTC.

Watch

Get told when its tools change: a new tool, a new description, a new class.

https://radar.anlyon.com/servers/com.autoview/mcp/changes.xml

An Atom feed. Works in any feed reader or Slack's RSS app.

Badge

Anlyon Radar badge for com.autoview/mcp
[![Anlyon Radar](https://radar.anlyon.com/badge/com.autoview/mcp.svg)](https://radar.anlyon.com/servers/com.autoview/mcp)

Source: MCP Registry · repository. Synced Nov 21, 2026, 08:17 UTC.

Autoview MCP server: questions and answers

Answered from the scan above, not from the publisher's description.

Is the Autoview MCP server safe?

No scan can promise that. What its definitions show: 20 tools, 13 of which can change, send or delete something, and 15 findings from fixed checks. Allow the reads, ask before each change, and deny the deletes; the permissions block on this page does that.

Can the Autoview MCP server delete data?

Yes. 4 tools can delete, cancel or revoke something: revoke_token, unlink, entry and paper_reset.

Can the Autoview MCP server do things that cannot be undone?

Yes. 1 tool can send, pay, publish or merge: send_feedback.

What tools does the Autoview MCP server have?

20 tools: 4 destructive, 1 irreversible, 8 write, 7 read. revoke_token, unlink, entry, paper_reset, send_feedback, connect, link, command and 12 more.

Does the Autoview MCP server need sign-in or OAuth?

Its remote endpoint listed its tools to an anonymous client, without sign-in.

Does the Autoview MCP server send data to outside services?

1 tool can carry data out (it sends, posts or publishes, or takes a recipient, channel or URL): send_feedback.

Has the Autoview MCP server changed its tools?

Yes, 10 times since Anlyon Radar started tracking it, most recently on Nov 21, 2026. Every change is on this page and in its Atom feed.