# Vurto Swap (remote · swap.vurto.cc)

Token swaps at the best net price on 9 EVM chains and Solana. No API key, non-custodial.

- Trust score: 64/100 (medium)
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-09-25

## Components

- remote · `swap.vurto.cc`: 64/100 (this document), [markdown](https://verifymcp.io/servers/cryptoconspiracy-vurto-swap/swap.md), [page](https://verifymcp.io/servers/cryptoconspiracy-vurto-swap/swap)

## Channel facts

- Endpoint: `https://swap.vurto.cc/mcp`
- Transports: `streamable-http`
- Auth: `none`
- Version: `1.0.0`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically against the live server, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-09-25.

- **Endpoint Security**: 69/100
  - The endpoint's TLS certificate is valid, in date, and uses a strong key.
  - No authorisation is required to call this server. Every tool declares its destructiveHint and none is destructive, so open access doesn't expose one.
  - HTTPS check failed: the endpoint is reachable over plaintext HTTP.
  - The HSTS (Strict-Transport-Security) header is present.
  - DNSSEC check failed: this domain isn't protected by DNSSEC.
- **Transport & Reachability**: 100/100
  - Verified streamable-http transport via a live MCP handshake.
- **Schema Quality & AI Usability**: 60/100
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 4788 tokens (~532/item across 9 items; 9 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 3/100
  - Stability observed for 1 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 95/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 84% of tool parameters carry a description.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - We read all 9 captured tool definition(s), and no name or description among them implies an irreversible operation.
  - An AI judge read all 10 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 40/100
  - Spec-recency check failed: implements MCP spec 2025-03-26; the latest is 2026-07-28.

## Install

### How do I install the Vurto Swap MCP server?

Vurto Swap is a hosted endpoint at https://swap.vurto.cc/mcp, so there is nothing to install locally. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add --transport http cryptoconspiracy-vurto-swap 'https://swap.vurto.cc/mcp'
```

### Cursor

```json
{
  "mcpServers": {
    "cryptoconspiracy-vurto-swap": {
      "url": "https://swap.vurto.cc/mcp"
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "cryptoconspiracy-vurto-swap": {
      "type": "http",
      "url": "https://swap.vurto.cc/mcp"
    }
  }
}
```

### Codex

```toml
[mcp_servers.cryptoconspiracy-vurto-swap]
url = "https://swap.vurto.cc/mcp"
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "cryptoconspiracy-vurto-swap": {
      "type": "remote",
      "url": "https://swap.vurto.cc/mcp",
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add cryptoconspiracy-vurto-swap --url 'https://swap.vurto.cc/mcp' --transport streamable-http
```

### Hermes

```yaml
mcp_servers:
  cryptoconspiracy-vurto-swap:
    url: "https://swap.vurto.cc/mcp"
```

### Netclaw

```json
{
  "McpServers": {
    "cryptoconspiracy-vurto-swap": {
      "Transport": "http",
      "Url": "https://swap.vurto.cc/mcp"
    }
  }
}
```

### Vellum

```bash
assistant mcp add cryptoconspiracy-vurto-swap -t streamable-http -u 'https://swap.vurto.cc/mcp'
```

### Other

```json
{
  "mcpServers": {
    "cryptoconspiracy-vurto-swap": {
      "type": "http",
      "url": "https://swap.vurto.cc/mcp"
    }
  }
}
```

The mcpServers block is a cross-client convention. Remote transports vary, so check your client's docs.

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-09-25 (score 64, 0)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-09-24 (score 64)

First indexed and scored.

## MCP tools (9)

### `swap_quote` (~511 tokens)

Compare ranked routes across providers for a swap, without building or spending anything. Ranked by net value after gas and platform fee, not raw output, with ONE unit price for the output token across every route, so a friendlier price feed can never put a route that delivers fewer tokens on top. Each quote also carries estimatedGas, the gas in units behind the same gasUsd, if you would rather rank against a gas price you read yourself. A quote is only usable by swap_build for about 10-12 seconds — do not hold onto a quoteId and build it later, quote again instead.

Input parameters:

- `amount` (string): Human decimal amount, e.g. "100". Use this OR amountRaw, not both.
- `amountRaw` (string): Raw integer string in tokenIn's smallest unit.
- `chainId` (integer|string, required): EVM: integer from GET /v1/chains (1, 10, 56, 100, 137, 8453, 42161, 43114, 130). Solana: string from GET /v1/svm/chains ("solana-mainnet").
- `receiver` (string): Optional: deliver the output to this address instead of the signing wallet. Only providers with supportsReceiver true on the resulting quote honor it — others are left out of quotes[] entirely rather…
- `slippageBps` (integer): Optional, a sane per-pair default applies when omitted.
- `tokenIn` (string, required): Contract address (Solana: mint), or symbol (case-insensitive). A symbol matching more than one token on this chain fails with ambiguous_token and every candidate — pick the address you meant and retr…
- `tokenOut` (string, required): Contract address, or symbol.
- `wallet` (string): Wallet that will sign. Required for builds and EVM execution/history calls. On an anonymous EVM quote, pass it to make the returned quoteId executable; without it the quote is indicative.

### `swap_build` (~790 tokens)

Build a signable/sendable plan for a swap. This is the tool that does the work — an agent that only knows this tool can execute a swap end to end. Quotes and builds the best route in one call when quoteId is omitted (recommended); pass quoteId from a prior swap_quote to build exactly that route instead. No API key required: pass the wallet that will sign. A machine credential is optional and only raises your limit from the per-IP cap to the credential budget. Four things to hold onto: 1. steps[] are ORDERED and REQUIRED. Skipping an approve step guarantees a revert. 2. If simulation.status is "approval_required", sign/send only the approve step(s), do not report them as the swap execution, then call swap_build again. If it is "incomplete", do not sign anything: the transaction was never independently verified. 3. If a step has type "signature", there is no transaction and never will be one for that step — what exists afterward is the uid from report_execution, not a hash. 4. If the provider is cowswap and the token sold is the chain's native asset, the transaction only REGISTERS the order — a successful receipt is not a successful swap. Use swap_status, not the receipt, to know what actually happened. 5. routeSwitch, when present, means the route you asked for refused to build (it hit its request limit) and the plan was built with another provider instead: {from, to, reason}. The quote in the plan is the route that will actually be signed. If the user picked that route themselves, say which provider replaced it before they sign.

Input parameters:

- `amount` (string): Human decimal amount, e.g. "100". Use this OR amountRaw, not both.
- `amountRaw` (string): Raw integer string in tokenIn's smallest unit.
- `chainId` (integer|string, required): EVM: integer from GET /v1/chains (1, 10, 56, 100, 137, 8453, 42161, 43114, 130). Solana: string from GET /v1/svm/chains ("solana-mainnet").
- `maxSlippageBps` (integer): Optional ceiling, 0-10000, enforced on every future refresh of this build — once set it never loosens.
- `quoteId` (string): Optional: build exactly this route from a prior swap_quote, instead of quoting fresh.
- `receiver` (string): Optional: deliver the output to this address instead of the signing wallet. Only providers with supportsReceiver true on the resulting quote honor it — others are left out of quotes[] entirely rather…
- `slippageBps` (integer): Optional, a sane per-pair default applies when omitted.
- `tokenIn` (string): Contract address (Solana: mint), or symbol (case-insensitive). A symbol matching more than one token on this chain fails with ambiguous_token and every candidate — pick the address you meant and retr…
- `tokenOut` (string): Contract address, or symbol.
- `wallet` (string, required): Wallet that will sign. Required for builds and EVM execution/history calls. On an anonymous EVM quote, pass it to make the returned quoteId executable; without it the quote is indicative.

### `double_quote` (~377 tokens)

Compares ranked routes for TWO swap legs at once — "Double Out" (one source token split into two destinations) or "Double In" (two source tokens converging on one destination). This exists because building a liquidity pool or matching a target ratio needs both legs priced against the market at the same instant, not one after another with the price moving in between. Each leg is independently quoted (two ordinary swap_quote calls under the hood) — this tool is a convenience that keeps them together, not a combined/atomic route. For mode "out": legA.tokenIn must equal legB.tokenIn (the shared source); tokenOut differs. For mode "in": legA.tokenOut must equal legB.tokenOut (the shared destination); tokenIn differs. Pass the exact amount each leg should trade — this tool does not compute percentages or splits for you. If the shared token is the chain's native asset, remember gas is paid twice (once per leg's eventual transaction) — do not quote/build a total that leaves nothing for the second leg's gas.

Input parameters:

- `chainId` (integer|string, required): EVM: integer from GET /v1/chains (1, 10, 56, 100, 137, 8453, 42161, 43114, 130). Solana: string from GET /v1/svm/chains ("solana-mainnet").
- `legA` (object, required)
- `legB` (object, required)
- `mode` (string, required): "out": one source, two destinations. "in": two sources, one destination.
- `wallet` (string): Wallet that will sign. Required for builds and EVM execution/history calls. On an anonymous EVM quote, pass it to make the returned quoteId executable; without it the quote is indicative.

### `double_build` (~307 tokens)

Builds signable/sendable plans for BOTH legs of a Double Out or Double In swap — two ordinary swap_build calls under the hood, kept together for convenience. Returns { legA, legB }, each a full SwapPlan exactly like swap_build's. The two legs are NOT atomic — there is no combined contract call, each is a transaction (or CoW signature) the wallet sends separately, same as any other swap. Execute leg A fully first (steps, signing, report_execution) and confirm it landed before starting leg B. If leg A fails or is rejected, do NOT execute leg B — proceeding would leave the wallet with only half the ratio the user asked for, which defeats the purpose of a Double swap.

Input parameters:

- `chainId` (integer|string, required): EVM: integer from GET /v1/chains (1, 10, 56, 100, 137, 8453, 42161, 43114, 130). Solana: string from GET /v1/svm/chains ("solana-mainnet").
- `legA` (object, required)
- `legB` (object, required)
- `maxSlippageBps` (integer): Optional ceiling, 0-10000, applied to both legs.
- `wallet` (string, required): Wallet that will sign. Required for builds and EVM execution/history calls. On an anonymous EVM quote, pass it to make the returned quoteId executable; without it the quote is indicative.

### `nn_quote` (~494 tokens)

N:N — quotes a basket where N input tokens fund M output tokens in ONE atomic on-chain transaction. The backend runs a waterfall allocation deciding which input finances which output, then quotes the real tokenIn->tokenOut route for each resulting slice through the same provider fan-out swap_quote uses. NOT decomposable into independent swap_quote/double_quote calls — the allocation itself is the thing being computed, not just N+M separate prices for legs you already know. inputLegs[]: what you sell (tokenIn + amount or amountRaw, each). outputLegs[]: what you want back, as outputPercent — an integer percent of the TOTAL basket value, not a fixed amount, because the actual split depends on the allocation; every outputLegs[].outputPercent in the request must sum to exactly 100. Up to 10 combined input+output legs; the waterfall never produces more than inputLegs.length + outputLegs.length - 1 real on-chain legs. Returns { legs[], failures[] }. Each entry in legs[] is a real quoted tokenIn->tokenOut leg (a NormalizedQuote under .quote, plus amountIn/tokenIn/tokenOut/receiver for that slice) — this is what nn_build will execute, not a rough preview. failures[] lists any slice that found no route; a partial basket is possible and reported, never silently dropped.

Input parameters:

- `chainId` (integer|string, required): EVM: integer from GET /v1/chains (1, 10, 56, 100, 137, 8453, 42161, 43114, 130). Solana: string from GET /v1/svm/chains ("solana-mainnet"). On EVM the multi-swap router must be deployed on the chain…
- `inputLegs` (array, required)
- `outputLegs` (array, required)
- `slippageBps` (integer): Optional, 5-500, applied to every leg. Default 50.
- `wallet` (string): Wallet that will sign. Required for builds and EVM execution/history calls. On an anonymous EVM quote, pass it to make the returned quoteId executable; without it the quote is indicative.

### `nn_build` (~508 tokens)

Builds ONE signable/sendable atomic transaction executing every leg of an N:N basket through VurtoSwapRouter. Always re-quotes the whole basket fresh from chainId/inputLegs/outputLegs — there is no quoteId handoff for N:N, pass the same fields used for nn_quote (or skip nn_quote and call this directly). No API key required: pass the wallet that will sign. A machine credential is optional and only raises your limit from the per-IP cap to the credential budget. Returns steps[]: one approve step per DISTINCT input token that still needs allowance, followed by ONE transaction step that executes every leg atomically. The approve target is the VurtoSwapRouter address (steps[].spender / the build's router), NOT each leg's underlying provider — this router pulls every input token itself inside one contract call, so approving providers individually the way swap_build does would approve the wrong address. If simulation.status is approval_required, send the approve step(s) first and call nn_build again for the executable transaction. legs[].routeSwitch, when present on a leg, means the provider the quote picked for THAT leg refused to build (it hit its request limit) and the leg was built with another provider instead: {from, to, reason}. Only that leg changed, the others are untouched, and the replacement is what will be signed: say which provider replaced it before the user signs. IMPORTANT: report_execution and swap_status do NOT support nn_build's transaction step — both key off a single quoteId, and this build has none (it is one transaction covering every leg, not one quote). After sending it, confirm success by checking the transaction receipt directly, not swap_status.

Input parameters:

- `chainId` (integer|string, required): EVM: integer from GET /v1/chains (1, 10, 56, 100, 137, 8453, 42161, 43114, 130). Solana: string from GET /v1/svm/chains ("solana-mainnet").
- `inputLegs` (array, required)
- `outputLegs` (array, required)
- `slippageBps` (integer): Optional, 5-500, applied to every leg. Default 50.
- `wallet` (string, required): Wallet that will sign. Required for builds and EVM execution/history calls. On an anonymous EVM quote, pass it to make the returned quoteId executable; without it the quote is indicative.

### `prepare_signing` (~441 tokens)

Synthesizes the local CLI signer invocation for one step of a swap_build plan. Does not call the Vurto backend — this only assembles the payload. You (the agent) do not need a private key and must never ask for one in chat: signing happens locally on the user's machine. RUN the command yourself as a background task (it blocks until the user approves/rejects/times out, then prints one JSON line and exits) and react to its exit — never ask the user "did you sign?". EVM supports "approve"/"transaction" steps (send tx.to/tx.data on-chain) and "signature" steps (sign step.typedData off-chain, EIP-712 — a CoW order; no gas, no transaction, no hash). expected_keys in the response tells you which result field to read: txHash for the first two, signature for the third. Solana has no steps[] and no approve: pass chainId "solana-mainnet" and step {transaction: build.transaction, executionRef: build.executionRef}. The response returns a different signer (Solana keys are not EVM keys) with the same shape, and expected_keys is signedTransaction — POST it to /v1/svm/execute, which broadcasts it and returns the signature.

Input parameters:

- `buildId` (string, required): From a prior swap_build/swap_refresh response.
- `chainId` (integer|string, required): EVM: integer from GET /v1/chains (1, 10, 56, 100, 137, 8453, 42161, 43114, 130). Solana: string from GET /v1/svm/chains ("solana-mainnet").
- `step` (object, required): EVM: one entry from swap_build's steps[]. Solana: {transaction, executionRef} from the build.
- `walletAddress` (string, required): The wallet the plan was built for. The signer refuses to sign if the connected wallet does not match. On Solana this is base58 and CASE-SENSITIVE: lowercasing it produces a different, non-existent ad…

### `report_execution` (~270 tokens)

Reports a completed swap, closing the loop. EVM transaction: pass wallet + txHash + quoteId; never report an approve step as an execution. EVM CoW signature: pass wallet + chainId + quoteId + signature; the server reloads the stored build and submits the signed order, returning uid (there is no transaction hash for this path). Solana: pass buildId + signature; the server verifies the fee payer and transaction on the network. No API key required; a machine credential only raises limits.

Input parameters:

- `buildId` (string): Solana: buildId returned by swap_build.
- `chainId` (integer|string): EVM CoW: integer chain id. Solana may use "solana-mainnet", but buildId + signature are sufficient.
- `quoteId` (string): EVM: quote id from the built plan.
- `signature` (string): EVM: EIP-712 CoW signature. Solana: transaction signature.
- `txHash` (string): EVM transaction swap only; do not report approve hashes.
- `wallet` (string): Wallet that will sign. Required for builds and EVM execution/history calls. On an anonymous EVM quote, pass it to make the returned quoteId executable; without it the quote is indicative.

### `swap_status` (~188 tokens)

Re-checks a swap. EVM: pass wallet + executionId (the id from report_execution); for CoW ETH-flow this consults the orderbook and distinguishes order_expired_refundable from order_expired_refunded instead of trusting the registration receipt. Solana: pass signature; answers come directly from the network and may be confirmed, pending, failed or expired.

Input parameters:

- `executionId` (string): EVM: the id returned by report_execution.
- `signature` (string): Solana: the transaction signature. Answers come from the network itself: confirmed, pending, failed, or expired (past lastValidBlockHeight the transaction can no longer enter any block).
- `wallet` (string): Wallet that will sign. Required for builds and EVM execution/history calls. On an anonymous EVM quote, pass it to make the returned quoteId executable; without it the quote is indicative.

## Diagnostics

Captured diagnostic sections: TLS, DNSSEC, Authorisation, Transports. The full working is on the page: https://verifymcp.io/servers/cryptoconspiracy-vurto-swap/swap#diagnostics

## Score history

- 2026-09-25: 64
- 2026-09-24: 64

## Common questions

### What is the Vurto Swap MCP server?

Vurto Swap is an MCP server listed in the public MCP registry as io.github.cryptoconspiracy/vurto-swap. Token swaps at the best net price on 9 EVM chains and Solana. No API key, non-custodial. This page covers its hosted endpoint (https://swap.vurto.cc/mcp).

### Is the Vurto Swap MCP server safe to use?

Vurto Swap scores 64 out of 100 on VerifyMCP. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the Vurto Swap MCP server expose?

Vurto Swap exposes 9 tools: swap_quote, swap_build, double_quote, double_build, nn_quote, and 4 more. Their descriptions and schemas cost roughly 3,886 tokens of context every time the server is loaded.

### Does the Vurto Swap MCP server require authentication?

No. We connected to Vurto Swap without credentials and it answered, so anything it exposes is reachable by anyone who knows the address.

### Is the Vurto Swap MCP server still maintained?

Vurto Swap is still listed as active in the MCP registry. We last reached this channel on 25 September 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

## Links

- Remote endpoint: https://swap.vurto.cc/mcp
- Website: https://swap.vurto.cc/agent-api.md
- Changelog RSS feed: https://verifymcp.io/servers/cryptoconspiracy-vurto-swap/swap.xml
- Changelog JSON feed: https://verifymcp.io/servers/cryptoconspiracy-vurto-swap/swap.json
- HTML version of this page: https://verifymcp.io/servers/cryptoconspiracy-vurto-swap/swap