DOCS

Vortr is a non-custodial swap on Base. You connect your own wallet, pick two Base assets, and trade them through the 0x aggregator. Vortr never holds your funds — you sign every trade yourself, and settlement happens directly on Base.

Supported Base assets include native ETH, WETH, USDC, USDT, DAI, and cbBTC.

1. 1
   Connect your wallet. Use the Connect button (RainbowKit). Make sure you're on Base mainnet.
2. 2
   Pick your tokens. Choose what you're selling and buying from the Base asset list (WETH, USDC, USDT, DAI, cbBTC, native ETH).
3. 3
   Enter an amount. A live quote from 0x appears — your you-receive estimate, the rate, and the real route the order will take.
4. 4
   Review the details. Check the rate, minimum received, price impact, slippage (default 0.5%, editable), and the network fee.
5. 5
   Hit Swap. An approve + swap is sent. Where your wallet supports ERC-5792, both are batched into one signature; otherwise they run as two sequential transactions (you'll see “tx 1 of 2”).
6. 6
   Confirm in your wallet. You approve the transaction in your own wallet — that's the only place anything is ever signed.

Prefer to just try it? Open the swap terminal →

Everything moving on the swap page is real on-chain / market data, not mock numbers:

• Prices, route & firm calldata0x aggregator
• Price chart (OHLCV) + the live Base-swaps feedGeckoTerminal
• USD valuesDefiLlama
• Your token balancesyour wallet RPC

What does non-custodial mean here?

Your keys, your funds. Vortr never holds, touches, or rehypothecates your assets — it only prepares a transaction that you sign in your own wallet. No deposit, no withdrawal, no Vortr account.

What is gas paid in?

Gas is paid in ETH on Base. Base is a low-fee Coinbase L2, so network fees are typically a few cents.

How does slippage protect me?

Your quote sets a minimum-received floor (default tolerance 0.5%, editable). If the price moves past that floor before your trade lands, the swap reverts instead of filling at a worse rate.

Is the "Live swaps" feed real?

Yes — it shows real on-chain Base swaps (via GeckoTerminal). One honest caveat: on-chain data cannot certify whether a given swap came from an agent or a human, so the feed does not claim to make that distinction.

Vortr ships a local stdio MCP server (server name vortr) with four tools. Quotes and firm calldata come from 0x; everything an agent needs to price and build a swap lives here. Vortr never signs.

Non-custodial signing is delegated to @walletchan/mcp: the user approves in the WalletChan browser-extension popup over WalletConnect. Vortr never holds keys and never signs.

Vortr is also a remote MCP over Streamable HTTP — add it as a custom connector in Claude (web / desktop) or any client that takes a remote MCP URL. No install, no keys, just paste:

https://www.vortr.xyz/mcp

In Claude: Settings → Connectors → Add custom connector, paste the URL, and the four tools (search_tokens, get_quote, get_portfolio, build_swap) appear.

Signing is not available over a remote URL — that is the non-custodial design (a hosted server can never touch your wallet). The remote connector covers research, quotes, and building calldata; build_swap returns the ERC-5792 calls plus a sign_url you open to connect your own wallet and confirm. For full programmatic signing, use the local stdio setup below with @walletchan/mcp.

1. 1
   walletchan.get_pairing_uri → if unpaired, show the wc: URI; the user pairs in the WalletChan extension.
2. 2
   walletchan.get_wallets → the approved Base account is the TAKER. Pin it.
3. 3
   vortr.get_quote(sellToken, buyToken, amount[BASE UNITS], taker) → price + route.
4. 4
   vortr.build_swap(...same...) → { payload, summary }.
5. 5
   Verify summary.taker === the get_wallets address. Abort on mismatch.
6. 6
   walletchan.send_calls({ chain: "base", from: summary.taker, calls: payload.calls }) → the user approves in the popup.
7. 7
   walletchan.get_request_status(requestId) → 100-199 pending / 200-299 confirmed / ≥400 failed.

# A swap, end to end. Vortr quotes & builds; WalletChan signs.

walletchan.get_pairing_uri()        # if unpaired → show wc: URI, user pairs
walletchan.get_wallets()            # TAKER = approved Base account (pin it)

vortr.get_quote(
  sellToken="USDC", buyToken="WETH",
  amount="1000000",                 # BASE UNITS — 1 USDC = "1000000"
  taker=TAKER,
)                                   # → buyAmount, minBuyAmount, route

{ payload, summary } = vortr.build_swap(...same args...)
assert summary.taker == TAKER       # abort on mismatch

walletchan.send_calls({
  chain: "base", from: summary.taker,
  calls: payload.calls,             # ERC-5792 approve + swap
})                                   # → user approves in WalletChan popup

walletchan.get_request_status(requestId)
# 100-199 pending · 200-299 confirmed · >=400 failed

The local stdio setup is the only mode that includes signing. Register two servers in any MCP-capable runtime — vortr for quoting/building and a wallet MCP (walletchan) for signing.

Claude Code

claude mcp add --scope user vortr \
  -e VORTR_API_BASE=<vortr url> \
  -e VORTR_API_SECRET=<secret> \
  -- npx -y @vortr/mcp

claude mcp add --scope user walletchan \
  -- npx -y @walletchan/mcp

The env var names are VORTR_API_BASE / VORTR_API_SECRET (internal legacy names, kept). The secret must match the web app's VORTR_API_SECRET.

Hermes Agent (NousResearch)

Add both servers under mcp_servers in ~/.hermes/config.yaml, then restart Hermes. Hermes only passes a safe baseline env to stdio subprocesses, so VORTR_API_BASE / VORTR_API_SECRET must live in the env: block:

# ~/.hermes/config.yaml — Hermes does NOT inherit your shell
# env for stdio servers, so the secrets MUST live in the env: block.
mcp_servers:
  vortr:
    command: "npx"
    args: ["-y", "@vortr/mcp"]
    env:
      VORTR_API_BASE: "<vortr url>"
      VORTR_API_SECRET: "<secret>"
    timeout: 60
    connect_timeout: 30
  walletchan:
    command: "npx"
    args: ["-y", "@walletchan/mcp"]

For local dev, point VORTR_API_BASE at your running web app and run the local binary instead of the published package:

node /path/packages/mcp/dist/index.js

The machine entry-point for any agent is /llms.txt.