Vurto Swap
REMOTE · SWAP.VURTO.CC
Token swaps at the best net price on 9 EVM chains and Solana. No API key, non-custodial.
Available components
Last scanned (18 hours ago)
Scores higher than 65% of remote servers
Reachable. Last reached 21 Nov 2026.
Category Crypto and Web3
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. How we score → Why this is hard to score →
Endpoint Security69
- The endpoint's TLS certificate is valid, in date, and uses a strong key. View diagnostics → Pass
- No authorisation is required to call this server. Nothing on it is marked destructive, but we can't show that an anonymous caller can only read: full credit needs the server to list at least one tool and every tool to be verifiably read-only. We use a best-effort check of tool names and descriptions to tell read-only tools from tools that change things, so some genuinely read-only tools may not get full credit. Names that start with a read verb (get, list, read, search and similar) and accurate readOnlyHint annotations help. Meet that to earn full credit, or require authorisation. See how to fix → View diagnostics → Partial
- HTTPS check failed: the endpoint is reachable over plaintext HTTP. See how to fix → View diagnostics → Fail
- The HSTS (Strict-Transport-Security) header is present. View diagnostics → Pass
- DNSSEC check failed: this domain isn't protected by DNSSEC. See how to fix → View diagnostics → Fail
Transport & Reachability100
- Verified streamable-http transport via a live MCP handshake. View diagnostics → Pass
Schema Quality & AI Usability53
- AI-judged instruction clarity (good).Pass
- Context-footprint check failed: tool/resource definitions use about 20921 tokens (~615/item across 34 items; 34 tools + 0 resources), over budget; trim descriptions and params. See how to fix → Fail
- Usage-examples check failed: none of the tools include examples. See how to fix → Fail
Stability & Change Management97
- Stability check failed: schema churn in the 30 days we've observed: 0 tool removals, 1 breaking changes, 0 auth/transport breaks, 16 additions. See how to fix → Fail
Tool Coverage97
- 100% of tools have a non-trivial description (not blank, and not just the tool's name).Pass
- 91% of tool parameters carry a description.Partial
Tool Safety100
- No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.Pass
- All 4 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation.Pass
- An AI judge read all 35 captured unit(s) of tool text and found none that tries to manipulate the model reading it.Pass
Capabilities40
- Spec-recency check failed: implements MCP spec 2025-03-26; the latest is 2026-07-28. See how to fix → Fail
Checks we ran (13)
- TLS certificate
- Authorization
- HTTPS
- HSTS header
- DNSSEC
- Transport
- Schema quality
- Stability
- Tool coverage
- Injection markers
- Destructive annotations
- Judged manipulation
- MCP protocol
Does not apply to this hosted endpoint (2)
- Supply Chain SecurityScored on package channels only. This is a hosted endpoint, so there is nothing to install or inspect.
- Provenance & TransparencyScored on package channels only. This is a hosted endpoint, so there is nothing to install or inspect.
The score does not measure everything. What the score does not measure →
Every change we have recorded for this component, newest first. Security-relevant changes are always shown. ▲ marks a change for the better, ▼ a change for the worse; unmarked changes are neutral.
- 20 Nov 26 0
- The server rewrote its instructions, which are the text every model session reads security
- Tool “check_analyze” rewrote its description, which is the text the model reads security
- Tool “check_buy_proof” rewrote its description, which is the text the model reads security
- Tool “check_charge” rewrote its description, which is the text the model reads security
- Tool “check_info” rewrote its description, which is the text the model reads security
- Tool “invoice_pay” rewrote its description, which is the text the model reads security
- “check_charge” reworded the description of “tools” cosmetic
- “invoice_create” reworded the description of “confidential” cosmetic
- 19 Nov 26 0
- The server rewrote its instructions, which are the text every model session reads security
- Tool “check_info” rewrote its description, which is the text the model reads security
- Tool “invoice_analysis_pay” rewrote its description, which is the text the model reads security
- Tool “invoice_create” rewrote its description, which is the text the model reads security
- Tool “invoice_get” rewrote its description, which is the text the model reads security
- Tool “invoice_pay” rewrote its description, which is the text the model reads security
- Tool “payout_charge” rewrote its description, which is the text the model reads security
- “invoice_create” reworded the description of “confidential” cosmetic
- 18 Nov 26 0
- The server rewrote its instructions, which are the text every model session reads security
- Tool “check_charge” rewrote its description, which is the text the model reads security
- Tool “check_info” rewrote its description, which is the text the model reads security
- Tool “invoice_analysis_pay” rewrote its description, which is the text the model reads security
- Tool “invoice_get” rewrote its description, which is the text the model reads security
- Tool “invoice_pay” rewrote its description, which is the text the model reads security
- Tool “payout_batch” rewrote its description, which is the text the model reads security
- New tool “kyc_proof” functional
- New tool “kyc_proof_challenge” functional
- “check_charge” added an optional parameter “tools” cosmetic
- “invoice_analysis_pay” added an optional parameter “walletProof” cosmetic
- “invoice_create” added an optional parameter “walletProof” cosmetic
- “payout_batch” added an optional parameter “walletProof” cosmetic
- “invoice_create” reworded the description of “payerChecks” cosmetic
- “payout_batch” reworded the description of “checks” cosmetic
- “wallet_check” reworded the description of “checks” cosmetic
- 13 Nov 26 −1
- Stability: pass → fail ▼ security
- A breaking change shipped without a version bump: still 1.0.0 ▼ security
- The server rewrote its instructions, which are the text every model session reads security
- Tool “check_charge” rewrote its description, which is the text the model reads security
- Tool “invoice_pay” rewrote its description, which is the text the model reads security
- “check_charge” added a required parameter “buyProof”, so existing callers break ▼ functional
- New tool “check_buy_challenge” functional
- New tool “check_buy_proof” functional
- 12 Nov 26 0
- The server rewrote its instructions, which are the text every model session reads security
- Tool “invoice_analysis_pay” rewrote its description, which is the text the model reads security
- Tool “invoice_get” rewrote its description, which is the text the model reads security
- Tool “payout_reuse” rewrote its description, which is the text the model reads security
- Tool “wallet_check” rewrote its description, which is the text the model reads security
- Schema quality: 13157 → 16573 ▼ functional
- Schema quality: excellent → good functional
- New tool “check_access” functional
- New tool “check_access_challenge” functional
- New tool “check_analyze” functional
- New tool “check_charge” functional
- New tool “check_credits” functional
- New tool “check_info” functional
- New tool “check_report_payment” functional
- New tool “check_result” functional
- “payout_batch” reworded the description of “checks” cosmetic
- “payout_charge” reworded the description of “txHash” cosmetic
- “payout_reuse” reworded the description of “token” cosmetic
- “wallet_check” reworded the description of “checks” cosmetic
- 11 Nov 26 +1
- Stability: 0.97 → pass security
- The server rewrote its instructions, which are the text every model session reads security
- Tool “invoice_analysis_pay” rewrote its description, which is the text the model reads security
- Tool “invoice_create” rewrote its description, which is the text the model reads security
- Tool “invoice_pay” rewrote its description, which is the text the model reads security
- “invoice_create” reworded the description of “payerChecks” cosmetic
- “invoice_create” reworded the description of “recipient” cosmetic
- 10 Nov 26 −1
- Stability: pass → 0.97 functional
- 8 Nov 26 0
- The server rewrote its instructions, which are the text every model session reads security
- Tool “destination_challenge” rewrote its description, which is the text the model reads security
- Tool “invoice_analysis_pay” rewrote its description, which is the text the model reads security
- Tool “invoice_create” rewrote its description, which is the text the model reads security
- Tool “invoice_get” rewrote its description, which is the text the model reads security
- Tool “invoice_pay” rewrote its description, which is the text the model reads security
- Tool “invoice_report_analysis_payment” rewrote its description, which is the text the model reads security
- Tool “payout_batch” rewrote its description, which is the text the model reads security
- Tool “payout_charge” rewrote its description, which is the text the model reads security
- “destination_challenge” added an optional parameter “chargeId” cosmetic
- “destination_challenge” added an optional parameter “chargeTxHash” cosmetic
- “prepare_signing” added an optional parameter “invoiceId” cosmetic
- “swap_build” added an optional parameter “invoiceId” cosmetic
- “swap_build” added an optional parameter “loteId” cosmetic
- “wallet_check” added an optional parameter “chainId” cosmetic
- “invoice_analysis_pay” reworded the description of “checks” cosmetic
- “invoice_analysis_pay” reworded the description of “payer” cosmetic
- “invoice_create” reworded the description of “checks” cosmetic
- “invoice_create” reworded the description of “confidential” cosmetic
- “invoice_create” reworded the description of “payerChecks” cosmetic
- “invoice_report_analysis_payment” reworded the description of “payer” cosmetic
- “payout_batch” reworded the description of “checks” cosmetic
- “payout_report_payment” reworded the description of “txHash” cosmetic
- “prepare_signing” reworded the description of “buildId” cosmetic
- “wallet_check” reworded the description of “checks” cosmetic
Diagnostic detail from the automated scan of this channel: what the scanner observed at each step, so you can see exactly where a check passed or failed. It is informational only and never changes the trust score.
Captured 21 Nov 2026 · Probed https://swap.vurto.cc/mcp
TLS valid
Negotiated TLS 1.3 with TLS_AES_128_GCM_SHA256 .
| Subject | Issuer | Valid from | Valid until | Key | Signature | Serial |
|---|---|---|---|---|---|---|
| CN=vurto.cc | CN=WE1,O=Google Trust Services,C=US | 29 Sept 2026 | 28 Dec 2026 | ECDSA 256 | ECDSA-SHA256 | 5a5dee180b5e44100e019c2d53dcc634 |
| SANs: vurto.cc, swap.vurto.cc, *.swap.vurto.cc | ||||||
| CN=WE1,O=Google Trust Services,C=US (CA) | CN=GTS Root R4,O=Google Trust Services LLC,C=US | 13 Dec 2023 | 20 Feb 2029 | ECDSA 256 | ECDSA-SHA384 | 7ff31977972c224a76155d13b6d685e3 |
| CN=GTS Root R4,O=Google Trust Services LLC,C=US (CA) | CN=GlobalSign Root CA,OU=Root CA,O=GlobalSign nv-sa,C=BE | 15 Nov 2023 | 28 Jan 2028 | ECDSA 384 | SHA256-RSA | 7fe530bf331343bedd821610493d8a1b |
Background: What to check on a remote MCP endpoint →
DNSSEC insecure
Validation of swap.vurto.cc. — Not signed
| Zone | DS | Keys | Algorithms | Outcome |
|---|---|---|---|---|
| . | Trust anchor | 20326, 38696 | 8, 8 | Verified |
| cc. | DS published | 12593 | 13 | Verified |
| vurto.cc. | No DS | Unsigned (proven) parent-signed NSEC/NSEC3 proves an unsigned delegation |
Authentication No authorisation required
The endpoint answered without asking for a token. Anyone who knows the URL can reach it.
| Result | No authorisation required |
|---|---|
| HTTP status | 200 |
| Header | Value |
|---|---|
| strict-transport-security | max-age=31536000; includeSubDomains |
| content-security-policy | default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'; img-src 'self' data: blob: https:; font-src 'self' data: https://fonts.reown.com; connect-src 'self' https://rpc.vurto.cc https://rpc-stage.vurto.cc https://api.web3modal.org https://*.walletconnect.org wss://*.walletconnect.org https://*.reown.com https://*.walletconnect.com wss://*.walletconnect.com; frame-src 'self' https://verify.walletconnect.com https://verify.walletconnect.org; media-src 'self' https://alive.vurto.cc https://alive-dev.vurto.cc; object-src 'none'; base-uri 'self'; form-action 'self'; frame-ancestors 'none' |
| x-content-type-options | nosniff |
| x-frame-options | DENY |
| referrer-policy | strict-origin-when-cross-origin |
| permissions-policy | camera=(), microphone=(), geolocation=(), payment=() |
Background: How OAuth 2.1 works in the 2026 MCP spec →
Transports 2 probes
| Transport | URL | Outcome | Status | Location |
|---|---|---|---|---|
| streamable-http | https://swap.vurto.cc/mcp | Verified | 200 | |
| http (plaintext) | http://swap.vurto.cc/mcp | Served over HTTP | 200 |
The tools this component advertises to a client, with an estimated token cost for each. Expand a tool to see its parameters and schema. The per-tool counts are indicative and are not scored directly; the schema's total context footprint is one signal in Schema Quality & AI Usability. A tool's description is untrusted text the model reads on every call, which is what makes this list a security surface and not just an inventory: how tool poisoning works →
check_access ~202
The Check access of a paying wallet, the proof check_credits asks for (access), valid 24 hours. Hand here the signature of check_access_challenge with its nonce and message, unchanged. The challenge is consumed here, once, so the access goes only to whoever holds that signature: keep it secret, it lists this payer's Checks. A challenge of another kind (destination_challenge, the claim of another charge) is refused with check_access_challenge_invalid. Returns { access, payer, expiresAt }.
| Name | Type | Req | Description |
|---|---|---|---|
| message | string | yes | From check_access_challenge, unchanged. |
| nonce | string | yes | From check_access_challenge. |
| signature | string | – | EVM: the EIP-191 or EIP-712 signature. Solana: the ed25519 signature in base58. |
| transaction | string | – | Solana: the signed proofTransaction (base64), never sent. |
| wallet | string | yes | The paying wallet. |
No output schema declared.
No examples provided.
check_access_challenge ~280
Only for check_credits (listing a payer's Checks by wallet); paying, analysing and reading one Check need only its id. The challenge of the Check access, of its own: the text says what the signature grants (read and use the paid Checks of this wallet for 24 hours), the site and until when to sign, and that it moves no funds and authorizes no destination. chainId is any network check_info lists: on EVM it is the domain of typedData, on Solana it gives proofTransaction. Returns { nonce, message, expiresAt, buildId (check-access-<nonce>), typedData (EVM) | proofTransaction (Solana) }. Sign it with prepare_signing (EVM: a signature step with typedData; Solana: the proofTransaction, never sent), then call check_access. Never use destination_challenge or destination_authorize for the Check: they do not give an access.
| Name | Type | Req | Description |
|---|---|---|---|
| chainId | integer|string | yes | EVM: integer from GET /v1/chains (1, 10, 56, 100, 137, 8453, 42161, 43114, 130). Solana: string from GET /v1/svm/chains ("solana-mainnet"). |
| wallet | string | yes | The paying wallet. |
No output schema declared.
No examples provided.
check_analyze ~595
Spends ONE paid credit on the networks it paid: evmWallet on the EVM networks paid, solanaWallet on Solana if it was paid. Give a wallet for each family the credit paid (check_wallet_missing otherwise) and none for a family it did not (check_family_not_paid). The free screening (OFAC SDN, issuer freeze) and Scorechain read each wallet once, Merkle Science (through Didit) once per network, at most the networks paid plus 2 lookups in all. Returns check with status used, target { wallets { evm, svm }, networks }, seal (the worst network: red, risk found; yellow, medium risk; grey, a paid reading did not come back; green, no risk, Merkle no_data included), result and screening (of the worst network), networks [{ chainId, seal, result { verdict, risk, tools [{ tool, result clear|flagged|unavailable, score 0-100, severity, summary, category, factors, sourceOfFunds, destinationOfFunds, analyzedAt, fromHistory }], details }, screening }] and events (the real steps, with ms). The same credit and the same wallets again answers what is stored, with no provider call; other wallets are check_credit_used (409). Two calls at once run ONE analysis (the other gets check_running, 409). check_unreadable (503): a reading did not answer, the credit is still valid, call again with the same arguments (details.missing names tool:network). analysis_tool_unavailable (503): a tool is down and the credit was not touched. The credit is per tool (independent review of 18/11/2026): a paid tool that cannot read now (crystal with the payer's KYC no longer approved, a tool Vurto switched off) is NOT spent: the others read, the result shows only them, and the answer carries pendingTools [{ tool, reason kyc_required|switched_off }] and pendingCheckId, a credit of its own for the pending tools bound to the same wallets (keep it like any Check id; call check_analyze with it later). With no paid tool able to read, check_tools_pending (409, details.pending) and nothing is spent.
| Name | Type | Req | Description |
|---|---|---|---|
| checkId | string | yes | The Check id from check_charge (CHK-...). It is the capability of this Check: keep it, and keep it private. |
| evmWallet | string | – | The EVM wallet to analyse (0x...), when the credit paid an EVM network. |
| solanaWallet | string | – | The Solana wallet to analyse (base58, case-sensitive), when the credit paid Solana. |
| wallet | string | – | Instead of the two above, for a credit of one family: the wallet, its family read from the address. |
No output schema declared.
No examples provided.
check_buy_challenge ~217
Step one of buying a Check (owner, 12/11/2026: only a wallet that passes the free screening buys, so it signs first). The challenge of its own, scope buy: the text says this wallet pays for a Check and is screened before buying, valid 10 minutes, and that it moves no funds and authorizes no destination. chainId is any network check_info lists. Returns { nonce, message, expiresAt, buildId (check-buy-<nonce>), typedData (EVM) | proofTransaction (Solana) }. Sign it with prepare_signing, then call check_buy_proof.
| Name | Type | Req | Description |
|---|---|---|---|
| chainId | integer|string | yes | EVM: integer from GET /v1/chains (1, 10, 56, 100, 137, 8453, 42161, 43114, 130). Solana: string from GET /v1/svm/chains ("solana-mainnet"). |
| wallet | string | yes | The paying wallet. |
No output schema declared.
No examples provided.
check_buy_proof ~248
Hand here the signature of check_buy_challenge with its nonce and message, unchanged. The challenge is consumed once, the wallet goes through the free screening (OFAC, issuer freezes), and only if it passes it returns { buyProof (vcb_..., 10 minutes, secret), payer, screening: passed, expiresAt }. It reads no KYC: whether this wallet may buy Crystal is POST /v1/check/buy/kyc with the buyProof, asked only when Crystal is wanted, and check_charge refuses Crystal with kyc_required otherwise. A blocked wallet gets payer_blocked (403). A challenge of another kind (check_access_challenge, destination_challenge) is refused with check_buy_challenge_invalid. Pass buyProof to check_charge.
| Name | Type | Req | Description |
|---|---|---|---|
| message | string | yes | From check_buy_challenge, unchanged. |
| nonce | string | yes | – |
| signature | string | – | EVM: the EIP-191 or EIP-712 signature. Solana: the ed25519 signature in base58. |
| transaction | string | – | Solana: the signed proofTransaction (base64), never sent. |
| wallet | string | yes | The paying wallet. |
No output schema declared.
No examples provided.
check_charge ~883
Builds the USDC transfer of the Check price for the networks and paid tools chosen (networks from check_info checkNetworks, tools from check_info toolOffer: the sum of each tool at its own price, never above its maximum) from payer to the analysis fee wallet on chainId (any network of check_info networks), for the payer to sign. The credit is bound to those networks. Needs buyProof, the purchase proof of THIS payer from check_buy_proof (the payer signed and passed the free screening); without it, or with another wallet's, check_buy_proof_required (401). The server also measures the sender on-chain. Returns { check { id, status awaiting_payment, amount, amountRaw, token, feeWallet, tools (exactly what this Check reads) }, skippedChecks? (tools asked for that are switched off or not on sale, left out and not charged), transaction, plan (buildId check-<id>, steps on EVM or transaction on Solana), report }. check.id (CHK-...) is the capability of this Check: whoever holds it reports the payment, analyses and reads the result, so keep it private and keep it to come back to the result. Each call makes a NEW Check, good for 30 minutes (expiresAt): a transaction mined after that is credited by the price of now on the networks it covers (check_report_payment). Pass checkId of one still awaiting payment and in its time to rebuild its transfer (the Solana one expires in about a minute). Sign the transaction exactly as returned: it carries the mark of THIS Check (16 bytes after the transfer arguments on EVM, a memo on Solana). A transfer you build yourself is refused with analysis_payment_rejected reason charge_not_tied after the money left: do not pay again, prove the wallet with destination_challenge (receiver = details.feeWallet, chargeId = the check id, chargeTxHash = that hash) and destination_authorize, then report the same hash again. Refusals: analysis_tool_unavailable (503, a tool is down: nothing is built), check_credit_limit (409), payer_blocked (403), check_network…
| Name | Type | Req | Description |
|---|---|---|---|
| buyProof | string | yes | The purchase proof of this payer from check_buy_proof (vcb_..., 10 minutes). Secret. |
| chainId | integer|string | yes | EVM: integer from GET /v1/chains (1, 10, 56, 100, 137, 8453, 42161, 43114, 130). Solana: string from GET /v1/svm/chains ("solana-mainnet"). |
| checkId | string | – | Optional: a Check still awaiting payment, to rebuild its transfer instead of making a new Check. |
| networks | array | yes | The networks to analyse, from check_info checkNetworks (e.g. ["1","8453","solana-mainnet"]). The price is perNetwork times these, never above maximum. |
| payer | string | yes | The paying wallet, the one that signs the transfer (0x on EVM, base58 on Solana). |
| tools | array | – | The paid tools to buy, at least one, each once (owner, 18/11/2026: one mark per paid tool): any of "scorechain" (once per wallet), "merkle-science" and "crystal" (once per network), from check_info t… |
No output schema declared.
No examples provided.
check_credits ~168
The paid Checks of a paying wallet, newest first, 50 a page with nextCursor: unused credits (status paid), a reading in flight or interrupted (status running: call check_analyze again with its target to resume) and the analyses already run (status used, with target and seal), to find a Check id you lost. The one check_* tool that reads by wallet, so the one that needs access, the Check access of this payer (check_access_challenge, then check_access).
| Name | Type | Req | Description |
|---|---|---|---|
| access | string | yes | The Check access of this payer from check_access (vca_...). Secret: it lists this payer's Checks. |
| cursor | string | – | nextCursor of the previous page, for the next 50. |
| payer | string | yes | The paying wallet. |
No output schema declared.
No examples provided.
check_info ~333
The paid Check of any wallet (owner, 18/11/2026: one mark per paid tool, the person chooses which; the free OFAC and issuer freeze screening always runs). toolOffer [{ tool, per ("wallet" or "network"), price, maximum, kycRequired? }]: each paid tool on sale, at its own price (dollars as text): scorechain per wallet (one reading answers every network of the family: an EVM wallet and a Solana one are two), merkle-science and crystal per network, each never above its maximum; crystal only for a payer with an approved KYC. A tool switched off or without a price is not listed. The price of a Check is the SUM over the tools chosen of price x units (wallets or networks), each capped at its maximum: the same reckoning check_charge charges. tools: the names on sale; defaultTools: what check_charge buys without tools (the pair, for older clients); freeScreening: ["ofac", "issuer-freeze"]. price { perNetwork, maximum, amount, currency }: Merkle Science alone, for older clients. checkNetworks [{ chainId, family }] (the seven to choose: 1, 10, 56, 137, 8453, 42161, solana-mainnet), networks [{ chainId, family, token (the USDC that pays), feeWallet }] (where it is paid: the nine EVM networks and solana-mainnet), creditLimit and chargeValidSeconds (1800). Public, no proof needed.
Input schema present but exposes no named parameters.
No output schema declared.
No examples provided.
check_report_payment ~285
Hand the Check payment to the server once it is mined, by the Check id. The server reads it on-chain (the payer the charge names signed it, the network USDC reached the fee wallet, at least the price, after the charge, the mark) and reserves the hash for this Check only. 201 with check.status paid: the credit exists. analysis_payment_pending (409): not mined yet, call again in a few seconds. analysis_payment_rejected (400, details.reason): this transaction does not pay this Check. tx_already_used (409): the hash already paid something else. check_not_found (404): no Check has this id. Mined after the charge's 30 minutes it still credits by the price of now on the networks it covers (lateCharge true, check.paidNetworks may be fewer); check_charge_expired (409) only when it covers none. check_credit_limit (409) and payer_blocked (403) are checked again here; nothing is reserved, so the same hash reported later still counts. Repeating the same hash is safe; never pay again.
| Name | Type | Req | Description |
|---|---|---|---|
| checkId | string | yes | The Check id from check_charge (CHK-...). It is the capability of this Check: keep it, and keep it private. |
| txHash | string | yes | The EVM transaction hash or the Solana signature. |
No output schema declared.
No examples provided.
check_result ~81
Reads one Check by its id, as stored (status, target, seal, result, screening, networks, events). Never calls a paid provider. An unknown id gets check_not_found (404).
| Name | Type | Req | Description |
|---|---|---|---|
| checkId | string | yes | The Check id from check_charge (CHK-...). It is the capability of this Check: keep it, and keep it private. |
No output schema declared.
No examples provided.
destination_authorize ~192
Hand over the signature of destination_challenge. The server checks it is the paying wallet's signature over that exact challenge, for that receiver and chain, unexpired and unused, and then lets builds deliver to that receiver for 30 minutes. Nothing else unlocks it. Errors: signature_invalid, authorization_expired, authorization_replayed, authorization_destination_mismatch, authorization_network_mismatch.
| Name | Type | Req | Description |
|---|---|---|---|
| chainId | integer|string | yes | – |
| message | string | yes | From destination_challenge, unchanged. |
| nonce | string | yes | From destination_challenge. |
| receiver | string | yes | – |
| signature | string | – | EVM: 0x hex, EIP-712 over typedData or EIP-191 over message. Solana: base58 over message. |
| transaction | string | – | Solana only: the signed proofTransaction, base64, instead of signature. |
| wallet | string | yes | – |
No output schema declared.
No examples provided.
destination_challenge ~347
Destination lock. A receiver different from the signing wallet is refused by swap_build, double_build and nn_build (403 destination_not_authorized) until the paying wallet signs an authorization for that exact address on that chain. This returns {nonce, message, expiresAt} plus, on EVM, typedData (EIP-712, the same fields) and, on Solana, proofTransaction (a memo that can never land, for Ledger). Show the user the full receiver and network and get their explicit yes; then sign: on EVM call prepare_signing with step {type: "signature", typedData} and run it; on Solana sign message (or proofTransaction) with the wallet. Then call destination_authorize. Never sign this without the user asking to send to that address. Paying an invoice to its receiver does not unlock through this, but an invoice with payerChecks asks for the same proof of the paying wallet (payer_signature_required).
| Name | Type | Req | Description |
|---|---|---|---|
| chainId | integer|string | yes | EVM chain id, or "solana-mainnet". |
| chargeId | string | – | Only to claim a payment of yours refused with charge_not_tied or tx_for_another_payment: the loteId or invoice id. Goes with chargeTxHash, and the report goes again to the route it was refused on; th… |
| chargeTxHash | string | – | Only with chargeId: the hash of the payment you are claiming. |
| receiver | string | yes | The full destination address. Solana base58 is case-sensitive. |
| wallet | string | yes | The wallet that pays and signs. |
No output schema declared.
No examples provided.
double_build ~307
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.
| Name | Type | Req | Description |
|---|---|---|---|
| chainId | integer|string | yes | 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 | yes | – |
| legB | object | yes | – |
| maxSlippageBps | integer | – | Optional ceiling, 0-10000, applied to both legs. |
| wallet | string | yes | 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. |
No output schema declared.
No examples provided.
double_quote ~377
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.
| Name | Type | Req | Description |
|---|---|---|---|
| chainId | integer|string | yes | 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 | yes | – |
| legB | object | yes | – |
| mode | string | yes | "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. |
No output schema declared.
No examples provided.
invoice_analysis_pay ~1,508
Do not use it on an invoice whose split.rule is "flat" or "brackets" (created since 10/11/2026): its fee is inside the payment and already pays the analysis of both wallets, and the call is refused with analysis_included_in_fee (409). Without checks: the charge of the invoice creator, for an older invoice with payerChecks or paid checks whose analysis.status is awaiting_payment (see invoice_get). Builds ONE USDC transfer of analysis.amount (the price written when that invoice was created: 0.10 Scorechain, 0.40 Merkle Science, 0.50 both) to the Vurto fee wallet (analysis.to), signed by the invoice creator. Sign the charge transaction exactly as returned: it carries the mark that ties the payment to this charge (16 bytes after the transfer arguments on EVM, a memo on Solana). A transfer you build yourself is refused with analysis_payment_rejected, reason charge_not_tied, after the money has left; do not pay again, prove the wallet (destination_challenge with wallet = payer, receiver = details.feeWallet, chargeId = this charge and chargeTxHash = that hash, then destination_authorize) and report the same hash again. Nothing is signed or sent here. The free screening runs first on the receiving wallet and on the creator: a rejected wallet gets screening_blocked (403) and nothing is built; a screening that cannot be read gets screening_unavailable (503). payer must be the creator (the receiving wallet when the invoice was created without a session, which is always the case over MCP); any other wallet gets not_invoice_creator (403) before anything is built. plan has the same shape as invoice_pay (prepare_signing; on Solana POST the signed transaction to /v1/svm/execute), then call invoice_report_analysis_payment with the hash or signature. Paying it from another token is a swap built over the HTTP API (POST /v1/swap on EVM, POST /v1/svm/swap on Solana) from the creator wallet with tokenOut = analysis.token, receiver = analysis.to and invoiceId = this invoice, sized so the…
| Name | Type | Req | Description |
|---|---|---|---|
| checks | array | – | The paid analyses of the RECEIVING wallet the payer buys. [] gives up an unpaid one, and only [] does: on an invoice whose payer analysis is split, leaving it out is invalid_check (400). |
| id | string | yes | INV-XXXX-XXXX or the 8-character id. |
| payer | string | yes | With checks: the paying wallet, which buys the analysis of the receiving wallet. Without checks: the invoice creator wallet, which pays the analysis it asked for (payerChecks, or the older paid check… |
| walletProof | string | – | Only when checks name "crystal": the walletProof of the PAYER from kyc_proof (vkp_..., 30 minutes). The destination authorization does not prove the wallet for Crystal; without the proof, kyc_wallet_… |
No output schema declared.
No examples provided.
invoice_create ~1,524
Create a payment request: who receives, which token, how much, on which network. Returns invoice.id, invoice.label (INV-XXXX-XXXX, what people copy), invoice.url (share this, after paying the analysis charge if the invoice has one; it previews with the QR on WhatsApp and Telegram) and invoice.qr (PNG). No signature or API key needed. New invoices only receive VERIFIED dollar stablecoins on the network allowlist, even without paid analysis. A new invoice without payerChecks carries no fee; with payerChecks, the analysis fee of both wallets is deducted from the amount through the split (see payerChecks). Previously created invoices keep their terms. Tokens resolve by address or symbol — an unverified token is refused because a cloned "USDC" with its own pool would let the creator sell a fake at any price. The payer can pay with ANY token on that network. Paid checks in checks are closed for new invoices (paid_check_moved): use payerChecks. the free screening of the receiving wallet must pass for the invoice to be created (receiver_blocked 403, screening_unavailable 503), and payerChecks adds the paid analysis of both wallets, paid by the fee deducted from the amount. A paid tool in payerChecks that Vurto switched off is left out and not charged, and the answer lists it in skippedChecks (never an error).
| Name | Type | Req | Description |
|---|---|---|---|
| amount | string | yes | Human decimal amount, e.g. "100". Decimals come from the token list, not from you. |
| chainId | integer|string | yes | EVM: integer from GET /v1/chains (1, 10, 56, 100, 137, 8453, 42161, 43114, 130). Solana: string from GET /v1/svm/chains ("solana-mainnet"). |
| checks | array | – | Closed for new invoices (07/11/2026): a paid check here ("scorechain", "merkle-science") is refused with paid_check_moved, on every network. Use payerChecks for the analysis of the paying wallet, and… |
| confidential | boolean | – | true creates a private invoice, paid through the Vurto Private Contract. It exists only where that contract is published for this network and token: elsewhere 400 private_coming_soon and nothing is c… |
| memo | string | – | Optional note, up to 80 chars, visible to anyone with the link. |
| payerChecks | array | – | Solana and EVM networks with invoiceSplit=true in /v1/chains, stablecoin invoices only: USDC, USDT (including USDT0), PYUSD, USDG and USD1, by verified address on each network. Availability differs b… |
| recipient | string | yes | Who receives: a wallet (EVM 0x address, or base58 on Solana, case-sensitive) or a Vurto user as "@handle". With "@handle" the Vurto Profile picks one of that user's wallets on this network (random am… |
| token | string | yes | Token to receive: address/mint or symbol of a verified dollar stablecoin on the network allowlist. Other tokens return stablecoin_required, even without paid analysis. |
| walletProof | string | – | Only with "crystal": the walletProof of THIS wallet (the receiver on invoice_create, the payer on payout_batch) from kyc_proof (vkp_..., 30 minutes). Secret. It proves the wallet is yours; the KYC it… |
No output schema declared.
No examples provided.
invoice_get ~433
Read an invoice by id (INV-XXXX-XXXX, with or without dashes): requested amount, token, network, receiver, status (open or paid), the paying transaction once paid, and received (the raw amount measured on-chain so far). Pending payments are re-checked on-chain by the read, at most two per read and each at most every 15 seconds. checks lists the older paid screening of an invoice created before 07/11/2026 ([] for new ones), which paying runs on both wallets once analysis.status is paid; payerChecks lists the analysis of the paying wallet the receiver asked and paid for. receiverAnalysisFee, on an open invoice where the payer can buy the receiving wallet analysis (invoice_analysis_pay with checks): {available: true, amount} is the charge in dollars, one consultation at the fixed price, or {available: false, minimum} when the amount is below the minimum and there is nothing to buy. For such an older invoice, analysis.report (Merkle Science only) carries, once the invoice is paid, the detail of both wallets; for payerChecks the result goes to the creator alone, on the site, and does not come here (over the web app, a signed session of the creator also sees the detail of the receiving wallet while it is open): score, severity, summary, main risk category, risk factors and sourceOfFunds (the largest origins of the money, up to 8, with category, entity, percentage, USD amount and direct or indirect exposure). confidential is true on a private invoice, with recipient null here. With privateContract: true it is paid only on its page through the Vurto Private Contract (invoice_pay answers private_invoice_vault_only) and paidTx stays null. With privateContract false it is a private invoice created before 14/10/2026: it can no longer be paid (invoice_pay answers private_invoice_paused), and its paying transaction, once paid, shows the receiver on-chain.
| Name | Type | Req | Description |
|---|---|---|---|
| id | string | yes | INV-XXXX-XXXX or the 8-character id. |
No output schema declared.
No examples provided.
invoice_pay ~1,748
Build the plan to pay an invoice from payer, with the token payer holds (default: the invoice token). Nothing is signed or sent here. Both wallets are screened first (payer_blocked, receiver_blocked); when the invoice has checks ["scorechain"] (see invoice_get), the creator chose and paid the Scorechain sanctions API, so this call sends the payer wallet and the receiver wallet to Scorechain, a third party (an invoice created before 22/10/2026 with the then-free Scorechain keeps running it without a charge). method "transfer": same token, a direct transfer built from the stored invoice (no fee, no gain; the receiver sees the payer as sender). method "swap": another token; amountIn is computed so the GUARANTEED minimum output covers the requested amount, the route is always the one with GAIN when there is one, and the output goes straight to the receiver (the transaction is public and signed by the payer, so the receiver can see the paying wallet on-chain). Any surplus over the requested amount goes to the receiver. plan has the same shape as a swap_build plan: on EVM sign steps[] in order with prepare_signing (approve steps first, then the transaction); on Solana pass {transaction, executionRef} to prepare_signing and POST the signed transaction to /v1/svm/execute. If simulation.status is approval_required, send the approve and call invoice_pay again. When the invoice has paid checks, the creator must have paid the analysis first (analysis_unpaid, 409). With "merkle-science" this call then sends the payer wallet and the receiver wallet to Didit/Merkle Science, and a HIGH or CRITICAL risk (score 70 or more) refuses with payer_blocked or receiver_blocked; the detail shows in invoice_get analysis.report. At most 3 different payer wallets are analysed per invoice by each paid check; a 4th gets analysis_attempts_exceeded (429). Since 23/10/2026 the payer proves the wallet BEFORE the paid analysis runs on it: over MCP that proof is the destination authorization signed by…
| Name | Type | Req | Description |
|---|---|---|---|
| id | string | yes | INV-XXXX-XXXX or the 8-character id. |
| payer | string | yes | The wallet that will sign and pay, on the invoice network. |
| slippageBps | integer | – | Optional, default 50. The guaranteed minimum is computed after it, so a tighter slippage asks the payer for less. |
| tokenIn | string | – | Optional: address/mint or symbol of the token the payer pays with. Omit to pay in the invoice token. |
No output schema declared.
No examples provided.
invoice_report_analysis_payment ~453
Hand the analysis payment transaction to the server once it is mined. The server reads it on-chain: a direct USDC transfer (the USDC of the invoice network) from the invoice creator to the Vurto fee wallet, of at least analysis.amount, newer than the invoice, never used for another analysis or invoice. screening_blocked (403): the free screening rejects the receiving wallet or the creator, and the payment is not registered. analysis_payment_pending (409): not mined yet, call again in a few seconds. analysis_payment_rejected (400) with details.reason (charge_not_tied, wrong_token, wrong_destination, amount_too_low, sender_not_creator, not_a_transfer, tx_reverted, tx_before_invoice): that transaction does not pay this analysis. charge_not_tied means it is not the transaction we built: do not pay again, prove the wallet (destination_challenge with receiver = details.feeWallet, chargeId = this invoice and chargeTxHash = that hash, then destination_authorize) and report the same hash again. Repeating a hash already recorded returns the status, and the stored result only with the receipt the first record returned (receiverAnalysis.receipt, sent back as receipt) or a proven wallet. tx_already_used (409): the hash already paid something else. Once paid, analysis.status is paid and the invoice can be paid. When the payer bought the analysis of the receiving wallet, pass payer too (the charge of the creator needs only txHash): the transaction must be signed by that payer and only the fee wallet may gain USDC in it (the split payment of an invoice never pays it, usdc_to_other_wallet); once paid the receiver analysis runs right away and receiverAnalysis.result comes back (verdict and the paid tools, never the receiving wallet).
| Name | Type | Req | Description |
|---|---|---|---|
| id | string | yes | INV-XXXX-XXXX or the 8-character id. |
| payer | string | – | The paying wallet that bought the receiver analysis, required when it was bought with checks. Leave it out for the analysis the creator paid. |
| txHash | string | yes | EVM transaction hash, or the Solana signature, of the analysis payment. |
No output schema declared.
No examples provided.
invoice_report_payment ~297
Hand the payment transaction to the server, right after sending it. The server reads the transaction on-chain and measures what reached the receiver in the invoice token; the payer must be the signer and the transaction must be newer than the invoice. The payer is screened again here (payer_blocked: a sanctioned or issuer-frozen payer does not count as paid, and once the network confirms the transaction the refusal is kept in the 10-year analysis record). With a paid analysis on the invoice and no prior proof of the payer wallet, the transaction itself is the proof: until the network confirms it the call returns payment_pending (409) and records nothing, so call again once it is mined. Pending until mined; invoice_get re-checks. An invoice holds at most 5 pending and 30 unconfirmed payments; past that, too_many_pending (429) until the network confirms the transaction, and a confirmed one is always accepted, so call again once it is mined. A hash pays each receiver once (tx_already_used once it confirmed another invoice of the same receiver and token); different receivers in one transaction are a batch payout.
| Name | Type | Req | Description |
|---|---|---|---|
| id | string | yes | INV-XXXX-XXXX or the 8-character id. |
| method | string | – | From invoice_pay.method. |
| payer | string | yes | The wallet that signed the payment. |
| txHash | string | yes | EVM transaction hash, or the Solana signature. |
No output schema declared.
No examples provided.
kyc_proof ~208
Hand here the signature of kyc_proof_challenge with its nonce and message, unchanged. The challenge is consumed once and it returns { walletProof (vkp_..., 30 minutes, secret), wallet, expiresAt }. Pass walletProof to invoice_create or payout_batch when they ask for "crystal" (API: header X-Wallet-Proof). It proves possession only: without an approved KYC on that wallet the call still answers kyc_required (403). A challenge of another kind is refused with kyc_proof_challenge_invalid.
| Name | Type | Req | Description |
|---|---|---|---|
| message | string | yes | From kyc_proof_challenge, unchanged. |
| nonce | string | yes | – |
| signature | string | – | EVM: the EIP-191 or EIP-712 signature. Solana: the ed25519 signature in base58. |
| transaction | string | – | Solana: the signed proofTransaction (base64), never sent. |
| wallet | string | yes | The wallet proved. |
No output schema declared.
No examples provided.
kyc_proof_challenge ~309
Step one of using Crystal from an agent (owner, 17/11/2026: the API, the MCP and the CLI need the KYC for Crystal too). Crystal runs only for a wallet whose identity check (KYC) is approved, and only when the caller proves it holds that wallet. This challenge of its own, scope kyc, says the wallet is yours so Vurto may use its KYC for the analyses that require it, valid 10 minutes to sign; it moves no funds, approves no payment and authorizes no destination. chainId is any network check_info lists (it picks the family; on EVM, the typed data domain). Returns { nonce, message, expiresAt, buildId (kyc-proof-<nonce>), typedData (EVM) | proofTransaction (Solana) }. Sign it with prepare_signing, then call kyc_proof. The KYC itself is done once by the person on the site; this only proves the wallet.
| Name | Type | Req | Description |
|---|---|---|---|
| chainId | integer|string | yes | EVM: integer from GET /v1/chains (1, 10, 56, 100, 137, 8453, 42161, 43114, 130). Solana: string from GET /v1/svm/chains ("solana-mainnet"). |
| wallet | string | yes | The wallet to prove: the receiver of the invoice, or the payer of the batch. |
No output schema declared.
No examples provided.
nn_build ~508
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.
| Name | Type | Req | Description |
|---|---|---|---|
| chainId | integer|string | yes | 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 | yes | – |
| outputLegs | array | yes | – |
| slippageBps | integer | – | Optional, 5-500, applied to every leg. Default 50. |
| wallet | string | yes | 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. |
No output schema declared.
No examples provided.
nn_quote ~494
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.
| Name | Type | Req | Description |
|---|---|---|---|
| chainId | integer|string | yes | 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 | yes | – |
| outputLegs | array | yes | – |
| 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. |
No output schema declared.
No examples provided.
payout_batch ~1,450
Payroll and supplier payouts to many wallets in one batch, on Solana and on the nine EVM chains (those with loteSplit true in GET /v1/chains). EVM: up to 50 wallets, in a verified USD stablecoin (USDC, USDT, PYUSD, USDG, USD1) — the batch is ONE transaction through the Vurto IBBs split contract, and the payer pays the exact amounts PLUS a 0.1% Vurto fee on the total. Solana: up to 50 wallets, in any token the payer holds (no swap, no fee), packed into one or a few transactions. The paying wallet and every receiving wallet are screened first (OFAC SDN list and, on Solana, the issuer freeze of six stablecoins); a blocked payer refuses with payer_blocked (403), and one blocked recipient refuses the whole batch with receiver_blocked (403) and details.index of that row, before anything is created. Each recipient becomes a regular invoice (history, on-chain verification). EVM returns { invoices[], evm: { split, invoiceIds[], base, fee, batchRef, deadline, steps[] } }: sign steps IN ORDER with prepare_signing (the approve step first, then the pay transaction step), send them, and call payout_report_payment with the PAY transaction hash and evm.invoiceIds. Solana returns { invoices[], transactions[] }: sign each transactions[i].transaction (prepare_signing, then POST to /v1/svm/execute) and call payout_report_payment with that signature and its invoiceIds. checks (stablecoin token, both families) adds a PAID analysis of every destination, turning the batch into two steps. Scorechain runs on every EVM chain and Solana; Merkle Science (Didit) does not cover Gnosis, Unichain or Avalanche, so a check the chain lacks refuses with check_not_available_on_chain. With checks the response carries no transactions[]: Solana returns { invoices[], charge: { buildId, transaction, loteId, total, token, tokenDecimals, feeWallet, recipients }, reused[] } (prepare_signing with buildId and step {transaction}, POST to /v1/svm/execute); EVM returns the same charge plus charge.step, a transactio…
| Name | Type | Req | Description |
|---|---|---|---|
| chainId | integer|string | yes | EVM: integer from GET /v1/chains (1, 10, 56, 100, 137, 8453, 42161, 43114, 130). Solana: string from GET /v1/svm/chains ("solana-mainnet"). |
| checks | array | – | Optional, both families, stablecoin token: the paid analysis tools to run on every destination ("crystal" only for a payer with an approved KYC, proven by walletProof from kyc_proof: kyc_wallet_signa… |
| payer | string | yes | The wallet that signs and pays. EVM 0x address, or base58 on Solana. |
| recipients | array | yes | – |
| token | string | yes | Mint or symbol of a verified token, e.g. "USDC". Every recipient is paid in it. On EVM it must be a USD stablecoin; with checks on Solana it must be a USD stablecoin too. |
| walletProof | string | – | Only with "crystal": the walletProof of THIS wallet (the receiver on invoice_create, the payer on payout_batch) from kyc_proof (vkp_..., 30 minutes). Secret. It proves the wallet is yours; the KYC it… |
No output schema declared.
No examples provided.
payout_charge ~460
Step 2 of a payout_batch with checks, on Solana or EVM. After signing and sending payout_batch's charge.transaction, hand its signature or hash here with the loteId and payer. The server verifies the charge on-chain, runs the paid analysis on EVERY destination, EXCLUDES any wallet that is blocked or over the payer's risk threshold (the payer's own, set on the site: one of five levels, 0, 20, 40 by default, 55 or 69; the verdict never carries the score) (it receives nothing, its money never moved), and returns { transactions[], evm?, approved[] (each with its scan result), rejected[] (wallet, reason) }. On Solana, sign each transactions[i].transaction (prepare_signing, POST to /v1/svm/execute) and call payout_report_payment with that signature and its invoiceIds. On EVM, sign evm.steps IN ORDER (approve, then pay the IBBs contract) and call payout_report_payment with the pay transaction hash and evm.invoiceIds. Idempotent with the same charge signature (re-returns the built batch, without the wallets already paid, listed in alreadyPaid). The charge hash goes only here, never to payout_report_payment. Errors: batch_charge_not_found, invalid_tx_hash, analysis_payment_pending (409, the network has not confirmed the charge yet, send the signature again shortly), analysis_payment_rejected (the transaction does not pay this charge; details.reason charge_not_tied when it is not the transaction payout_batch built: do not pay again, prove the wallet with destination_challenge (receiver = details.feeWallet, chargeId = the loteId, chargeTxHash = that hash), then destination_authorize, and call this again), tx_already_used.
| Name | Type | Req | Description |
|---|---|---|---|
| loteId | string | yes | The loteId from payout_batch's charge. |
| payer | string | yes | The wallet that paid the charge (base58 on Solana, 0x on EVM). |
| txHash | string | – | The Solana signature or EVM transaction hash of the charge payment. Omit only to rebuild a batch with nothing to charge, every destination below the analysis minimum. |
No output schema declared.
No examples provided.
payout_report_payment ~128
Hand one batch transaction to the server, right after sending it, with the invoiceIds that payout_batch listed for it. Each invoice is verified on-chain like any invoice payment (what reached that receiver); call again a few seconds later if some are still pending.
| Name | Type | Req | Description |
|---|---|---|---|
| invoiceIds | array | yes | EVM: payout_batch evm.invoiceIds (all of them, paid by the one pay transaction). Solana: payout_batch.transactions[i].invoiceIds. |
| payer | string | yes | The wallet that signed. |
| txHash | string | yes | The Solana signature or EVM transaction hash. |
No output schema declared.
No examples provided.
payout_reuse ~329
Preview which wallets in a batch (Solana or EVM) ran this analysis for this payer in the last 30 days: a hint, read with no network call; whether it comes from the history is decided when the charge is paid, by the movement measured then; every one still pays its share of the fee. This reveals a payer's own analysis history, so it needs the paying wallet's signed session; the MCP carries no session, so paid is always [] and the batch charges every destination. With each recipient's amount and a USD stablecoin token it also returns fee { amount (dollars, the analysis charge payout_batch would build), charged (destinations in it), belowMinimum (indexes of the lines below the minimum, which go without the paid analysis), minimum }. Returns { paid: string[], fee? }.
| Name | Type | Req | Description |
|---|---|---|---|
| chainId | integer|string | yes | EVM: integer from GET /v1/chains (1, 10, 56, 100, 137, 8453, 42161, 43114, 130). Solana: string from GET /v1/svm/chains ("solana-mainnet"). |
| checks | array | yes | The paid analysis tools, same as the batch. |
| payer | string | yes | The paying wallet (base58 on Solana, 0x on EVM). |
| recipients | array | yes | The destination wallets, same list as the batch. |
| token | string | – | The batch token address, same as the batch. Required on EVM; on Solana needed only for fee. |
No output schema declared.
No examples provided.
prepare_signing ~524
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.
| Name | Type | Req | Description |
|---|---|---|---|
| buildId | string | yes | The buildId of the plan you are signing: swap_build, swap_refresh, invoice_pay, invoice_analysis_pay, payout_batch, payout_charge or destination_challenge. |
| chainId | integer|string | yes | EVM: integer from GET /v1/chains (1, 10, 56, 100, 137, 8453, 42161, 43114, 130). Solana: string from GET /v1/svm/chains ("solana-mainnet"). |
| invoiceId | string | – | When invoice_pay returned method "swap": the invoice id, so the next step points to invoice_report_payment. Record the swap with report_execution too. Not for "swap_then_transfer": that swap goes to… |
| step | object | yes | EVM: one entry from swap_build's steps[]. Solana: {transaction, executionRef} from the build. |
| walletAddress | string | yes | 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… |
No output schema declared.
No examples provided.
report_execution ~270
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.
| Name | Type | Req | Description |
|---|---|---|---|
| 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. |
No output schema declared.
No examples provided.
swap_build ~967
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): a route with GAIN first, re-quoting up to 3 rounds total before accepting one without gain, the same rule as Invoice; 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 with quoteId set to the quote.id of that build (the approved route; without it a fresh quote may pick another provider whose spender you never approved). 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.
| Name | Type | Req | Description |
|---|---|---|---|
| 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 | yes | EVM: integer from GET /v1/chains (1, 10, 56, 100, 137, 8453, 42161, 43114, 130). Solana: string from GET /v1/svm/chains ("solana-mainnet"). |
| invoiceId | string | – | Paying an analysis charge with another token: the invoice id, with receiver = the fee wallet of that charge. Same rule for the minimum. |
| loteId | string | – | Paying a batch charge with another token: the loteId from payout_batch, with tokenOut = charge.token and receiver = charge.feeWallet. The guaranteed minimum must stay between the charge and 10% above… |
| 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 | yes | 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. |
No output schema declared.
No examples provided.
swap_quote ~543
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.
| Name | Type | Req | Description |
|---|---|---|---|
| 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 | yes | 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 | yes | 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 | yes | 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. |
No output schema declared.
No examples provided.
swap_status ~188
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.
| Name | Type | Req | Description |
|---|---|---|---|
| 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. |
No output schema declared.
No examples provided.
wallet_check ~430
Check any wallet (EVM 0x address or Solana base58, case-sensitive) before paying it or taking its money: OFAC SDN list on both families; on Solana also the issuer freeze of USDC and EURC (Circle), USDT (Tether), PYUSD and USDG (Paxos) and USD1 (World Liberty), the issuer freeze index, and a fund trail up to three hops back. Returns verdict passed, blocked or unavailable, with each check. Paying an invoice (invoice_pay) runs this check on the receiving wallet and refuses with receiver_blocked, so a payment through Vurto Payments never reaches a sanctioned or frozen wallet. To pay someone directly, create an invoice to their wallet (invoice_create) and pay it with invoice_pay. Plain swaps (swap_build, double_build, nn_build) do not run it. The Scorechain and Merkle Science checks are paid: buy them for any wallet with check_charge and check_analyze (the Check), or inside an invoice with invoice_analysis_pay; asking for them here returns paid_check_requires_invoice (400).
| Name | Type | Req | Description |
|---|---|---|---|
| chainId | integer|string | – | The network that will pay, to read the wallet on it: the answer gets network.state (verified, no_activity, contract, not_a_wallet, invalid, unread). Solana addresses are read without it. |
| checks | array | – | Kept for compatibility; leave it out. Every extra check is paid since 22/10/2026 (since 16/11/2026 at a fixed price per consultation, https://docs.vurto.cc/fees) and runs only once paid: inside an in… |
| wallet | string | yes | The wallet to check. EVM 0x address, or Solana base58 (case-sensitive). |
No output schema declared.
No examples provided.
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.
remote · swap.vurto.cc
claude mcp add --transport http cryptoconspiracy-vurto-swap 'https://swap.vurto.cc/mcp'
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 76 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 34 tools: swap_quote, swap_build, double_quote, double_build, nn_quote, and 29 more. Their descriptions and schemas cost roughly 17,286 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 21 November 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.
What did VerifyMCP test on the Vurto Swap MCP server?
VerifyMCP ran 13 checks on Vurto Swap, covering TLS certificate, Authorization, HTTPS, HSTS header and 9 more. Supply Chain Security and Provenance & Transparency do not apply to a hosted endpoint, so they were not tested. The score does not measure everything, and the scoring documentation lists what it leaves out.