Vurto Swap

Measured conclusion: Deep-tested. L2 outcome: tools_ok.

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

Add to your agent

Copy this into your MCP client config:

{
  "mcpServers": {
    "Vurto Swap": {
      "url": "https://swap.vurto.cc/mcp",
      "transport": "streamable-http"
    }
  }
}

Measured tools (18)

• swap_quote read-only

  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.

  Parameters:

  • chainId (required) — ['integer', 'string'] — EVM: integer from GET /v1/chains (1, 10, 56, 100, 137, 8453, 42161, 43114, 130). Solana: string from GET /v1/svm/chains ("solana-mainnet").
  • tokenIn (required) — 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 retry. On Solana only VERIFIED tokens resolve by symbol, because there anyone can mint a token using another one's symbol; an unverified token has to be named by its mint.
  • tokenOut (required) — string — Contract address, or symbol.
  • amount — string — Human decimal amount, e.g. "100". Use this OR amountRaw, not both.
  • 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.
  • 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 than risk sending to the wrong address. supportsReceiver is present on Solana quotes too, so read it instead of assuming. On Solana, selling into native SOL with a separate destination is refused on every provider (receiver_native_sol_unsupported): closing the wrapped-SOL account sends balance and rent to whoever signs. Ask for wSOL instead. Building with a receiver needs the paying wallet's signed authorization first (destination_challenge, then destination_authorize), or the build fails with destination_not_authorized.
  • amountRaw — string — Raw integer string in tokenIn's smallest unit.
  • slippageBps — integer — Optional, a sane per-pair default applies when omitted.

  Hints: read-only yes · destructive no · idempotent no · open-world yes

• swap_build

  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.

  Parameters:

  • chainId (required) — ['integer', 'string'] — 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 (required) — 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.
  • amount — string — Human decimal amount, e.g. "100". Use this OR amountRaw, not both.
  • quoteId — string — Optional: build exactly this route from a prior swap_quote, instead of quoting fresh.
  • 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 retry. On Solana only VERIFIED tokens resolve by symbol, because there anyone can mint a token using another one's symbol; an unverified token has to be named by its mint.
  • 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 than risk sending to the wrong address. supportsReceiver is present on Solana quotes too, so read it instead of assuming. On Solana, selling into native SOL with a separate destination is refused on every provider (receiver_native_sol_unsupported): closing the wrapped-SOL account sends balance and rent to whoever signs. Ask for wSOL instead. Building with a receiver needs the paying wallet's signed authorization first (destination_challenge, then destination_authorize), or the build fails with destination_not_authorized.
  • tokenOut — string — Contract address, or symbol.
  • amountRaw — string — Raw integer string in tokenIn's smallest unit.
  • slippageBps — integer — Optional, a sane per-pair default applies when omitted.
  • maxSlippageBps — integer — Optional ceiling, 0-10000, enforced on every future refresh of this build — once set it never loosens.

  Hints: read-only no · destructive no · idempotent no · open-world yes

• double_quote read-only

  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.

  Parameters:

  • mode (required) — string — "out": one source, two destinations. "in": two sources, one destination.
  • chainId (required) — ['integer', 'string'] — 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 (required) — object
  • legB (required) — object
  • 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.

  Hints: read-only yes · destructive no · idempotent no · open-world yes

• double_build

  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.

  Parameters:

  • chainId (required) — ['integer', 'string'] — 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 (required) — 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.
  • legA (required) — object
  • legB (required) — object
  • maxSlippageBps — integer — Optional ceiling, 0-10000, applied to both legs.

  Hints: read-only no · destructive no · idempotent no · open-world yes

• nn_quote read-only

  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.

  Parameters:

  • chainId (required) — ['integer', 'string'] — 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 or the quote fails with multi_swap_not_supported_on_chain; on Solana there is no router contract, several top-level instructions in one transaction are already all-or-nothing by runtime rule.
  • inputLegs (required) — array
  • outputLegs (required) — array
  • 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.
  • slippageBps — integer — Optional, 5-500, applied to every leg. Default 50.

  Hints: read-only yes · destructive no · idempotent no · open-world yes

• nn_build

  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.

  Parameters:

  • chainId (required) — ['integer', 'string'] — 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 (required) — 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.
  • inputLegs (required) — array
  • outputLegs (required) — array
  • slippageBps — integer — Optional, 5-500, applied to every leg. Default 50.

  Hints: read-only no · destructive no · idempotent no · open-world yes

• prepare_signing read-only

  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.

  Parameters:

  • buildId (required) — string — From a prior swap_build/swap_refresh response.
  • walletAddress (required) — string — 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 address.
  • chainId (required) — ['integer', 'string'] — 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 (required) — object — EVM: one entry from swap_build's steps[]. Solana: {transaction, executionRef} from the build.

  Hints: read-only yes · destructive no · idempotent yes · open-world no

• report_execution

  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.

  Parameters:

  • 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.
  • 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.

  Hints: read-only no · destructive no · idempotent yes · open-world yes

• swap_status read-only

  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.

  Parameters:

  • 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.
  • 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).
  • executionId — string — EVM: the id returned by report_execution.

  Hints: read-only yes · destructive no · idempotent yes · open-world yes

• invoice_create

  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; it previews with the QR on WhatsApp and Telegram) and invoice.qr (PNG). No signature or API key needed. Only VERIFIED tokens of the network are accepted, 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. Optional checks: ["scorechain"] adds the Scorechain sanctions API to the screening of BOTH wallets (payer and receiver) whenever this invoice is paid; it sends both wallets to Scorechain, a third party, so it runs only when chosen. A wallet listed by Scorechain is refused (payer_blocked or receiver_blocked); when Scorechain cannot be read the payment is not held, because the OFAC list is already checked here.

  Parameters:

  • chainId (required) — ['integer', 'string'] — EVM: integer from GET /v1/chains (1, 10, 56, 100, 137, 8453, 42161, 43114, 130). Solana: string from GET /v1/svm/chains ("solana-mainnet").
  • recipient (required) — string — Wallet that receives. EVM 0x address, or base58 on Solana (case-sensitive).
  • token (required) — string — Token to receive: address/mint or symbol of a verified token on this network.
  • amount (required) — string — Human decimal amount, e.g. "100". Decimals come from the token list, not from you.
  • memo — string — Optional note, up to 80 chars, visible to anyone with the link.
  • checks — array — Optional extra screening chosen by the invoice creator; default none. "scorechain": when this invoice is paid, both wallets (payer and receiver) are also checked against the Scorechain sanctions API, which means both are sent to Scorechain. Runs only when chosen. Any other value is refused with invalid_check.
  • confidential — boolean — Not available yet: private invoices are coming soon, with the Vurto vault. Any value other than false is refused with private_coming_soon and nothing is created. A payment is a direct transfer, so the transaction shows the receiving wallet on-chain; omit this field.

  Hints: read-only no · destructive no · idempotent no · open-world yes

• wallet_check read-only

  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. Optional checks: ["scorechain"] also asks the Scorechain sanctions API; it sends the wallet to Scorechain, a third party, so it runs only when chosen, and has a tighter per-IP limit (10 per hour). Its line reads listed, clear or unavailable; unavailable does not hold the verdict.

  Parameters:

  • wallet (required) — string — The wallet to check. EVM 0x address, or Solana base58 (case-sensitive).
  • checks — array — Optional extra checks; default none. "scorechain" sends this wallet to the Scorechain sanctions API and adds a scorechain line (listed, clear or unavailable). Runs only when chosen; limited to 10 per hour per IP. Any other value is refused with invalid_check.

  Hints: read-only yes · destructive no · idempotent yes · open-world yes

• destination_challenge

  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 does not need it.

  Parameters:

  • wallet (required) — string — The wallet that pays and signs.
  • receiver (required) — string — The full destination address. Solana base58 is case-sensitive.
  • chainId (required) — ['integer', 'string'] — EVM chain id, or "solana-mainnet".

  Hints: read-only no · destructive no · idempotent no · open-world yes

• destination_authorize

  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.

  Parameters:

  • wallet (required) — string
  • receiver (required) — string
  • chainId (required) — ['integer', 'string']
  • nonce (required) — string — From destination_challenge.
  • message (required) — string — From destination_challenge, unchanged.
  • 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.

  Hints: read-only no · destructive no · idempotent no · open-world yes

• invoice_get read-only

  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 extra screening the creator chose (e.g. ["scorechain"]; [] when none), which paying runs on both wallets. confidential is true only on a private invoice created before 14/10/2026: its receiver reads null here, it can no longer be paid (invoice_pay answers private_invoice_paused), and its paying transaction, once paid, shows the receiver on-chain.

  Parameters:

  • id (required) — string — INV-XXXX-XXXX or the 8-character id.

  Hints: read-only yes · destructive no · idempotent yes · open-world yes

• invoice_pay

  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 the Scorechain sanctions API, so this call sends the payer wallet and the receiver wallet to Scorechain, a third party. 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. Then call invoice_report_payment with the hash (EVM) or signature (Solana). Errors: price_moved (the minimum fell below the request between quote and build — call again), no_route, native_sol_only (an invoice in SOL can only be paid in SOL), invoice_already_paid, private_invoice_paused (a private invoice created before 14/10/2026, paused until the Vurto vault exists). Both wallets are screened before the plan is built: the paying one (payer_blocked) and the receiving one (receiver_blocked). screening_unavailable (503) means the screening could not finish, try again in a few seconds.

  Parameters:

  • id (required) — string — INV-XXXX-XXXX or the 8-character id.
  • payer (required) — string — The wallet that will sign and pay, on the invoice network.
  • tokenIn — string — Optional: address/mint or symbol of the token the payer pays with. Omit to pay in the invoice token.
  • slippageBps — integer — Optional, default 50. The guaranteed minimum is computed after it, so a tighter slippage asks the payer for less.

  Hints: read-only no · destructive no · idempotent no · open-world yes

• payout_batch

  Payroll and supplier payouts on Solana: pay up to 20 wallets their exact amounts, in the token the payer holds (no swap). The paying wallet and every receiving wallet are screened first (OFAC SDN list and 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). Returns { invoices[], transactions[] }: the transfers are packed in as few transactions as fit the network limit, each with its invoiceIds. Sign each transactions[i].transaction (prepare_signing, then POST to /v1/svm/execute), then payout_report_payment with that signature and those invoiceIds. Errors: batch_svm_only, batch_duplicate_recipient (add the amounts up in one row), batch_self_payment, too_many_recipients, token_not_listed, screening_unavailable (503, try again).

  Parameters:

  • chainId (required) — string
  • token (required) — string — Mint or symbol of a verified token, e.g. "USDC". Every recipient is paid in it.
  • payer (required) — string — The wallet that signs and pays.
  • recipients (required) — array

  Hints: read-only no · destructive no · idempotent no · open-world yes

• payout_report_payment

  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.

  Parameters:

  • txHash (required) — string — The Solana signature.
  • payer (required) — string — The wallet that signed.
  • invoiceIds (required) — array — From payout_batch.transactions[i].invoiceIds.

  Hints: read-only no · destructive no · idempotent yes · open-world yes

• invoice_report_payment

  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). 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.

  Parameters:

  • id (required) — string — INV-XXXX-XXXX or the 8-character id.
  • payer (required) — string — The wallet that signed the payment.
  • txHash (required) — string — EVM transaction hash, or the Solana signature.
  • method — string — From invoice_pay.method.

  Hints: read-only no · destructive no · idempotent yes · open-world yes

Publisher website

Measured by MCPYP probing. Untested fields are omitted, never estimated. Listing is always free; MCPYP never proxies calls or stores user tokens.