MCP Radar
MCP Server

Laso Finance

finance.laso/laso-finance
Crypto & Web3 Payments & Fintech Auth required MCP 2025-11-25

What this MCP does

Enables USDC-funded prepaid cards, gift cards, bank payouts, push-to-card payments, managed wallets, and banking workflows.

Capabilities

Tools

62 tools
add_banking_destination
Attach bank details to a recipient Attaches a bank account or crypto address to a recipient and returns the `destination_id` that `/send-bank-payment` pays out to. Free.
Input schema 
{'type': 'object', 'required': ['recipientId', 'destination'], 'properties': {'nickname': {'type': 'string', 'example': 'Rent account', 'description': 'An optional label. The only field editable later, via `updateBankingDestination`.'}, 'auth_token': {'type': 'string', 'description': 'Laso credential. Only if the MCP connection has no Authorization header.'}, 'destination': {'type': 'object', 'description': 'The destination. For a US bank account: `destination_type: "fiat_us"` plus `aba_routing_number`, `account_number`, `account_type`, `account_holder_name`, and `bank_name`. Also supports `fiat_iban` and `crypto`.'}, 'recipientId': {'type': 'string', 'description': 'The recipient from `createBankingRecipient`.'}, 'recipientAddress': {'type': 'object', 'description': "Sets the recipient's postal address before attaching the destination. Needed when the recipient was created name-only: bank destinations are rejected without one, so supplying it here avoids a dead end."}}}
agent_wallet_transfer
Transfer USDC out of your managed agent wallet to any Solana address. Use this to recover funds or move them to another wallet you control.
Input schema 
{'type': 'object', 'required': ['destination_address', 'amount'], 'properties': {'amount': {'type': 'string', 'description': 'Decimal USDC amount to send, as a string (e.g. 25.50).'}, 'auth_token': {'type': 'string', 'description': 'Laso credential. Only if the MCP connection has no Authorization header.'}, 'destination_address': {'type': 'string', 'description': 'Solana address to send the USDC to.'}}}
announce_connection
Call this FIRST, before any other Laso tool. Your human is watching a screen that waits for you to connect; this is what resolves it, names you in their dashboard, and starts a session in their activity stream. Introduce yourself with agent_name and message. Also returns your wallet funding state, so it doubles as your setup check.
Input schema 
{'type': 'object', 'properties': {'message': {'type': 'string', 'description': 'A short greeting shown to your human, in your own words. Max 280 characters.'}, 'agent_name': {'type': 'string', 'description': "What to call you in your human's dashboard, e.g. Claude Code. Max 60 characters."}, 'auth_token': {'type': 'string', 'description': 'Laso credential. Only if the MCP connection has no Authorization header.'}}}
cancel_intl_order
Cancel a queued international card order Cancel a previously queued international non-reloadable card order, as long as it has not yet been fulfilled by an admin (`state=queued`). The charged amount is credited back to the account balance.
Input schema 
{'type': 'object', 'required': ['card_id'], 'properties': {'card_id': {'type': 'string', 'description': 'The card ID of the queued order to cancel (returned from `/order-intl-card`)'}, 'auth_token': {'type': 'string', 'description': 'Laso credential. Only if the MCP connection has no Authorization header.'}}}
create_agent_api_key
Issue an API key Issues a durable `lasoak_` API key for the account. **The raw key is returned once** — only its hash is stored, so it cannot be retrieved again. Normally the human does this from the dashboard. Free.
Input schema 
{'type': 'object', 'properties': {'label': {'type': 'string', 'example': 'Claude Code', 'description': 'A label to recognize the key by.'}, 'auth_token': {'type': 'string', 'description': 'Laso credential. Only if the MCP connection has no Authorization header.'}}}
create_agent_wallet
Create your managed agent wallet (one per account; idempotent). Returns the wallet's Solana address. Fund it with USDC to pay for the paid tools.
Input schema 
{'type': 'object', 'properties': {'auth_token': {'type': 'string', 'description': 'Laso credential. Only if the MCP connection has no Authorization header.'}}}
create_banking_account
Open an on-ramp or off-ramp account Opens a banking rail. An **on-ramp** issues a virtual US bank account: dollars sent to it arrive as USDC in the managed wallet. An **off-ramp** pays out to a bank account you have registered, and is opened automatically by `/send-bank-payment`, so most agents never call this for one directly. Free.
Input schema 
{'type': 'object', 'required': ['accountType'], 'properties': {'rail': {'type': 'string', 'description': 'The payment rail for the account.'}, 'asset': {'type': 'string', 'example': 'USDC', 'description': 'Crypto asset ticker, uppercase.'}, 'networkId': {'type': 'string', 'description': 'On-ramp only. Defaults to Solana mainnet.'}, 'auth_token': {'type': 'string', 'description': 'Laso credential. Only if the MCP connection has no Authorization header.'}, 'accountType': {'enum': ['onramp', 'offramp'], 'type': 'string', 'description': 'Which rail to open.'}, 'capabilities': {'type': 'array', 'items': {'type': 'string'}, 'description': 'On-ramp only. Bank rails to support. Defaults to ACH and wire.'}, 'cryptoAddress': {'type': 'string', 'description': 'On-ramp only. Where the converted USDC should land. Defaults to the managed agent wallet.'}, 'fiatDestinationId': {'type': 'string', 'description': 'Off-ramp only. The bank destination payouts go to, from `addBankingDestination`.'}}}
create_banking_profile
Create the banking profile Opens the banking profile that all other banking calls hang off. Identity verification is required first; if the human has not verified, the reply carries `kycRequired: true` and a `kycUrl` to hand them. **This is the only step an agent cannot complete itself.** Retry once they finish. Free.
Input schema 
{'type': 'object', 'properties': {'auth_token': {'type': 'string', 'description': 'Laso credential. Only if the MCP connection has no Authorization header.'}}}
create_banking_recipient
Create a payout recipient Creates a person or company money can be sent to. Bank details are attached separately with `addBankingDestination`. Free.
Input schema 
{'type': 'object', 'required': ['name'], 'properties': {'name': {'type': 'string', 'example': 'Acme LLC', 'description': "The recipient's name."}, 'address': {'type': 'object', 'description': "The recipient's postal address. Required before a bank destination can be attached, so supplying it here avoids a second call."}, 'auth_token': {'type': 'string', 'description': 'Laso credential. Only if the MCP connection has no Authorization header.'}}}
create_reloadable_card
Create a reloadable card Creates a **reloadable** card funded from the account holder's balance with the card issuer, and returns it. This is the same card the holder creates in the Laso dashboard, so an agent and a human end up with the same product. The card is **reusable by default** (`reusable: true`): it stays open across charges until its limit is spent. Pass `reusable: false` for a single-use card that closes after its first approved charge. **This route is free** — no x402 payment. The card draws on the account holder's own balance with the issuer, so Laso fronts nothing. **If the balance is short**, this route answers `402`. Fund it by sending USDC: `GET /get-card-deposit-address` returns the holder's own deposit address at the card issuer (USDC on Base only), and the balance credits within a couple of minutes. The holder can also top up with Apple or Google Pay in the dashboard. Read the new card's number and CVV with `/get-card-data?card_id=...`. A card created here is Laso-issued, so its `card_details` come back directly — the approval step applies only to cards the holder created in a different app.
Input schema 
{'type': 'object', 'required': ['usd_amount'], 'properties': {'reusable': {'type': 'boolean', 'description': 'Whether the card stays open across charges. Defaults to `true`; `false` closes it after the first approved charge.'}, 'auth_token': {'type': 'string', 'description': 'Laso credential. Only if the MCP connection has no Authorization header.'}, 'usd_amount': {'type': 'number', 'description': 'Amount in US dollars to load onto the card, minimum $1. Sent as dollars, not cents.'}}}
delete_address_book_entry
Remove a saved recipient The saved recipient names your human manages on their dashboard, so a request like "send $20 to the coffee vendor" can be resolved to an address instead of asking them for it. Free. It operates only on the authenticated account's own book — there is no user parameter to pass. **A name is a label, not an instruction.** `agentWalletTransfer` takes an address and deliberately does not accept a name: a rename between your human asking and you sending would otherwise move money somewhere they did not intend. When you resolve a name to an address, say the address back to them before sending. Removing an entry only forgets the name; it has no effect on past transfers to that address.
Input schema 
{'type': 'object', 'properties': {'address': {'type': 'string', 'description': 'The address to remove.'}, 'auth_token': {'type': 'string', 'description': 'Laso credential. Only if the MCP connection has no Authorization header.'}}}
delete_banking_recipient
Delete a recipient Deletes a recipient, its destinations, and any off-ramp account that paid out to it. Irreversible. Free.
Input schema 
{'type': 'object', 'required': ['recipientId'], 'properties': {'auth_token': {'type': 'string', 'description': 'Laso credential. Only if the MCP connection has no Authorization header.'}, 'recipientId': {'type': 'string', 'description': 'The recipient to delete.'}}}
delete_payment_recipient
Remove a saved recipient (free) Removes a saved Venmo or PayPal recipient. Payment history is kept; only the saved entry stops being offered. This is not reversible through the API, so prefer archiving (`POST /payment-recipients` with `archived: true`) when the account owner may want the recipient back, and confirm before removing someone they did not ask you to remove. `platform` and `recipient_id` may be sent in the JSON body or the query string.
Input schema 
{'type': 'object', 'properties': {'platform': {'enum': ['venmo', 'paypal'], 'type': 'string', 'description': 'Required unless sent in the body.'}, 'auth_token': {'type': 'string', 'description': 'Laso credential. Only if the MCP connection has no Authorization header.'}, 'recipient_id': {'type': 'string', 'description': "Required unless sent in the body. The entry's `recipient_id` from `GET /payment-recipients` (an opaque id, not the phone number or email)."}}}
delete_webhook
Delete the notification webhook (free) Removes the calling wallet's webhook registration. Notifications keep flowing to the user's other channels (push, SMS, Telegram, in-app); only the webhook deliveries stop. The account owner is notified of the removal.
Input schema 
{'type': 'object', 'properties': {'auth_token': {'type': 'string', 'description': 'Laso credential. Only if the MCP connection has no Authorization header.'}}}
exchange_api_key
Exchange an API key for a session Exchanges a durable `lasoak_` API key for a short-lived `id_token` (one hour) plus a `refresh_token`, and returns an `auth_url` to hand your human so they can watch what you do. This is the first call an agent makes. The reply's `id_token` authenticates every other endpoint here. If you have no key, your human creates one at https://laso.finance/agent/dashboard — there is no other way to obtain one. Free.
Input schema 
{'type': 'object', 'required': ['api_key'], 'properties': {'api_key': {'type': 'string', 'example': 'lasoak_...', 'description': 'Your `lasoak_` API key.'}}}
fund_card_balance
Load a reloadable card balance Pay USDC to load the account holder's reloadable card balance at the card issuer. **Why this exists:** the card issuer only accepts USDC on **Base**, and a Laso managed agent wallet holds USDC on **Solana**. Pay this route from either chain and Laso bridges the payment to your own deposit address at the issuer over Circle's CCTP, which burns on the source chain and mints native USDC on Base. **Price:** exactly the amount you are loading, and exactly that amount is credited to the balance. Loading $50 costs $50 and puts $50 on the card. Laso covers Circle's bridging fee by burning slightly more than requested. **A linked card issuer account is required.** The account holder sets it up at https://laso.finance/agent/dashboard/verified/card. **Delivery starts once your payment settles.** The response confirms the payment and returns a `top_up_id`; the transfer to your card balance follows and usually lands in under a minute. A payment made on Base is already on the issuer's chain, so it is forwarded without a bridge. Watch the top-up under `top_ups` in `GET /list-card-transactions`, where `status` moves `paid` → `bridging` → `delivered` → `credited` and the transaction hash behind each leg appears as it lands, or poll `GET /get-card-deposit-address` until `balance` reflects it. **Follow with `POST /create-reloadable-card`** to create a card against the balance once it has arrived. **If the top-up's status becomes `failed`**, nothing is stranded: the USDC you paid has credited your Laso account balance. Retry, or recover it with `POST /withdraw`. PAID ROUTE (5-1000 USD): the x402 USDC price is paid automatically from your managed agent wallet. Make sure the wallet exists and is funded first (get_agent_wallet).
Input schema 
{'type': 'object', 'required': ['amount'], 'properties': {'amount': {'type': 'number', 'maximum': 1000, 'minimum': 5, 'description': 'USD of USDC to load onto the card balance (min $5, max $1,000). The x402 price equals this amount; Laso absorbs the bridge cost.'}, 'auth_token': {'type': 'string', 'description': 'Laso credential. Only if the MCP connection has no Authorization header.'}}}
get_account_balance
Get account balance Returns the current account balance and total deposits for the authenticated user.
Input schema 
{'type': 'object', 'properties': {'auth_token': {'type': 'string', 'description': 'Laso credential. Only if the MCP connection has no Authorization header.'}}}
get_agent_spend_limit
Read the per-payment spend limit Returns the maximum the account owner allows for any single payment from the managed wallet: `maxPerPaymentUsdc`, plus the `min`, `max`, and `default` bounds it can be set within, all in whole USDC. The limit defaults to $1,000 and ranges from $1 to $50,000. It applies to every payment `agentX402Pay` makes, Laso routes and external `url` endpoints alike. Check an amount against this **before** attempting a payment rather than waiting to be refused. Compare the fee-inclusive total, since fees are added on top of the amount you request. Read-only to an agent: only the account owner can change the limit, from the dashboard. If a payment would exceed it, do not split it into smaller payments. Stop and tell your human. Free.
Input schema 
{'type': 'object', 'properties': {'auth_token': {'type': 'string', 'description': 'Laso credential. Only if the MCP connection has no Authorization header.'}}}
get_agent_wallet
Get your managed agent wallet: whether one exists, its Solana address, its USDC balance, and whether it needs funding. Paid tools draw from this wallet, so check it before your first paid call. Fund it by sending USDC (Solana) to wallet_address.
Input schema 
{'type': 'object', 'properties': {'auth_token': {'type': 'string', 'description': 'Laso credential. Only if the MCP connection has no Authorization header.'}}}
get_auth_link
Get a login link for the web dashboard Returns a URL that a human can open in a browser to log in to the Laso Finance web dashboard as the authenticated user. Useful for humans who want to see what their AI agent has been doing (view cards, transactions, balances, etc.). The URL carries a short single-use login code rather than a long token, so relay it to your human verbatim; it passes through tool-output credential filters intact. Do not fetch or open the URL yourself: redeeming the code consumes the human's login.
Input schema 
{'type': 'object', 'properties': {'auth_token': {'type': 'string', 'description': 'Laso credential. Only if the MCP connection has no Authorization header.'}}}
get_banking_application
Read the banking application Reads what the application still needs. Returns `ready` (whether it can be submitted), `applicationStatus`, and the outstanding questions. The identity answers carry over from verification; what remains are non-identity questions such as employment status and source of funds, which an agent can answer itself. Free.
Input schema 
{'type': 'object', 'properties': {'auth_token': {'type': 'string', 'description': 'Laso credential. Only if the MCP connection has no Authorization header.'}}}
get_banking_profile_status
Check the banking profile status Reads the current state of the banking profile: whether it exists, and where its application stands. Free.
Input schema 
{'type': 'object', 'properties': {'auth_token': {'type': 'string', 'description': 'Laso credential. Only if the MCP connection has no Authorization header.'}}}
get_banking_transaction
Read one transaction Reads a single banking transaction — an on-ramp arriving or an off-ramp paying out — with its normalized status. Free.
Input schema 
{'type': 'object', 'required': ['transactionId'], 'properties': {'auth_token': {'type': 'string', 'description': 'Laso credential. Only if the MCP connection has no Authorization header.'}, 'transactionId': {'type': 'string', 'description': 'The transaction to read.'}}}
get_card
Order a USA prepaid card Pay between $5–$1000 USDC to order a Laso Finance USA prepaid card. By default returns JSON with auth credentials and card info (for AI agents). Pass `format=html` to get an HTML redirect to the card redemption URL (for browser-based flows). The JSON response includes a `card.status` of `"pending"`. Card details (number, CVV, etc.) take ~7-10 seconds to become available. Poll `getCardData` at the `callableBaseUrl` to check when `status` becomes `"ready"`. **U.S. only.** This card is issued in USD and can only be used for purchases at U.S.-based merchants. Physical goods must ship to a U.S. address. For non-U.S. merchants or non-USD currencies, use `GET /order-intl-card` instead. This endpoint is intended for the caller's own use — the card is non-transferable. PAID ROUTE (5-1000 USD): the x402 USDC price is paid automatically from your managed agent wallet. Make sure the wallet exists and is funded first (get_agent_wallet).
Input schema 
{'type': 'object', 'required': ['amount'], 'properties': {'amount': {'type': 'number', 'maximum': 1000, 'minimum': 5, 'description': 'USD amount to load on the card (min $5, max $1000)'}, 'format': {'enum': ['json', 'html'], 'type': 'string', 'default': 'json', 'description': 'Response format. `json` (default) returns auth credentials and card info for agents. `html` returns a redirect page for browsers.'}, 'auth_token': {'type': 'string', 'description': 'Laso credential. Only if the MCP connection has no Authorization header.'}}}
get_card_data
Get card details Returns the current status and details of card orders. If `card_id` is provided, returns a single card, looked up across U.S. non-reloadable, international non-reloadable, and reloadable cards. If omitted, returns all cards of the given `card_type` for the authenticated user; `card_type` defaults to `Non-Reloadable U.S.` when omitted, so existing callers see unchanged behavior. Pass `card_type=Non-Reloadable International` to list international cards, or `card_type=Reloadable` to list reloadable cards. For U.S. non-reloadable cards, details take ~7-10 seconds to become available after ordering; poll every 2-3 seconds until `status` is `"ready"`, then read `card_details`. For international non-reloadable cards, the order is `queued` until an admin fulfills it (typically within 24 hours), after which `card_details` is populated. For international cards, the `card_id` returned by `/order-intl-card` is a queue id. After admin fulfillment, the issuer's transaction id becomes the new `card_id` and the original queue id is preserved on the card as `queued_order_card_id`. You can keep polling `/get-card-data?card_id=<original-queue-id>` and it will resolve to the fulfilled card. **Reloadable cards** are a separate product, set up by the account holder in the Laso dashboard rather than ordered through this API. They are reusable (a `multi_use` card stays open across charges until its limit is spent) and can be topped up, unlike the single-load non-reloadable cards. Listing them returns `balance`, `spend_limit`, `last4`, `expiry`, and `reusable`. If the wallet has no card issuer account linked, the list is empty and a `note` explains how the holder sets one up. Reading a reloadable card's **number and CVV** is gated by the card issuer, and which gate applies depends on who issued it. Request the card by `card_id`; the response carries exactly one of three fields. `card_details` is the normal result for a card created through `/create-reloadable-card`, which Laso issues on the holder's behalf and can read for them directly — no approval step is involved. `details_approval` with `status: "pending"` and an `approval_id` appears only for a card the holder created in a DIFFERENT app: the issuer has emailed them an approve/deny link, and once they approve you retry as `GET /get-card-data?card_id=<CARD_ID>&approval_id=<APPROVAL_ID>` to receive `card_details`. `details_error` means the issuer could not return the number; retry shortly, and if it persists the holder can read the card in the dashboard. Spend the card by entering its number, expiry, and CVV at the merchant's checkout. `billing_address` is null on these cards and always will be — the issuer holds no billing address for a card. If a merchant requires one, use the address the account holder gave at identity verification (ask them; do not guess), since these cards are AVS-checked against it and a mismatch is the most common decline on a card that has funds. A card with `reusable: true` stays open after an approved charge and can be spent again up to its remaining `balance`; a charge larger than the balance is declined in full, as there are no partial approvals.
Input schema 
{'type': 'object', 'properties': {'card_id': {'type': 'string', 'description': "The card ID returned from `/get-card` or `/order-intl-card`, or a reloadable card's id from `card_type=Reloadable`. Looked up across all three card types. If omitted, returns all cards of `card_type`."}, 'card_type': {'enum': ['Non-Reloadable U.S.', 'Non-Reloadable International', 'Reloadable'], 'type': 'string', 'default': 'Non-Reloadable U.S.', 'description': 'When listing all cards (no `card_id`), filters by card type. Defaults to `Non-Reloadable U.S.` if omitted (preserves existing client behavior). Pass `Non-Reloadable International` to list international cards, or `Reloadable` to list reloadable cards.'}, 'auth_token': {'type': 'string', 'description': 'Laso credential. Only if the MCP connection has no Authorization header.'}, 'approval_id': {'type': 'string', 'description': 'Reloadable cards only, and only for a card the account holder created in a DIFFERENT app: pass the approval_id from a prior details_approval response once they have approved it. Cards created through /create-reloadable-card are Laso-issued and never require this.'}}}
get_card_deposit_address
Get the reloadable card deposit address Returns the account holder's own USDC deposit address at the card issuer, and the balance currently on it. **This is how an agent funds a reloadable card balance with crypto.** Funding is user-funded: the address belongs to the account holder, so USDC sent to it credits their balance and funds their cards. The issuer provisions the address on first read, so simply calling this creates it. **Base only.** The address takes USDC on Base. USDC sent on another chain is unrecoverable. A Laso managed agent wallet holds USDC on **Solana**, so fund from a wallet that holds USDC on Base rather than transferring straight from a managed wallet. Deposits usually confirm within a couple of minutes. Poll this endpoint until `balance` reflects the deposit, then call `POST /create-reloadable-card`. The address is stable per holder, but read it through this endpoint rather than caching it: the issuer is the only authority on it.
Input schema 
{'type': 'object', 'properties': {'auth_token': {'type': 'string', 'description': 'Laso credential. Only if the MCP connection has no Authorization header.'}}}
get_kyc_link
Get a KYC verification link (optional) **KYC is optional.** It is only needed for certain features such as Venmo/PayPal payouts via `/send-payment`, and may be used for additional controls in the future. If you are not using those features, you can ignore the verification endpoints. Returns a one-time identity-verification link (`kyc_url`) for the calling wallet. Open it (or hand it to the wallet owner) to complete verification. The typical flow is: call `/get-kyc-status`, and only if `kyc_verified` is `false` call this to get a link, complete it, then proceed to `/send-payment`.
Input schema 
{'type': 'object', 'properties': {'auth_token': {'type': 'string', 'description': 'Laso credential. Only if the MCP connection has no Authorization header.'}}}
get_kyc_status
Get KYC verification status (optional) **KYC is optional.** Most endpoints (cards, gift cards, push-to-card, account balance, withdrawals) do not require verification. It is only needed for certain features such as Venmo/PayPal payouts via `/send-payment`, and may be used for additional controls in the future. If you are not using those features, you can ignore the verification endpoints entirely. Returns the calling wallet's cached KYC verification status. Use this as a free pre-flight check before paying for `/send-payment`: if `kyc_verified` is `true` the payout will go through. If it is `false`, don't call `/send-payment` yet — that call would not send the payout (it returns `kyc_required` and a `kyc_url`), and the USDC you paid would just land in your account balance, recoverable with `POST /withdraw`. To start verification when not verified, call `/get-kyc-link`. This reads the cached status kept up to date by the verification webhook; it does not start verification or return a verification link.
Input schema 
{'type': 'object', 'properties': {'auth_token': {'type': 'string', 'description': 'Laso credential. Only if the MCP connection has no Authorization header.'}}}
get_payment_status
Check Venmo and PayPal payout status (free) Reports the state of the Venmo and PayPal payouts this account has sent with `GET /send-payment`. Free: only the payout itself is a paid action. Three ways to call it: with `payment_id` to fetch one payout, with `recipient_id` (from `GET /payment-recipients`) to list every payout to that saved recipient, or with neither to list every payout this account has sent, newest first. `state` is `queued` (waiting on account balance), `in-process` (dispatched to the platform), `complete`, `failed`, or `cancelled`. `queued` and `in-process` are the two states still in flight; poll every few minutes, or register a webhook with `POST /register-webhook` to be told when a payout completes instead. A payout that has been `in-process` for more than an hour is worth raising with the account owner. `state` is absent on payouts sent before state tracking existed. Bank payouts are not listed here: follow those with `listBankingTransactions`. Push-to-card transfers are completed by the recipient in the browser and have no server-side state.
Input schema 
{'type': 'object', 'properties': {'auth_token': {'type': 'string', 'description': 'Laso credential. Only if the MCP connection has no Authorization header.'}, 'payment_id': {'type': 'string', 'description': 'Fetch one payout by its `id`. Takes precedence over `recipient_id`.'}, 'recipient_id': {'type': 'string', 'description': 'List every payout to one saved recipient. This is the `recipient_id` returned by `GET /payment-recipients`, not the phone number or email.'}}}
get_signup_status
Wait for your human to finish the signup Long-polls until the human opens the claim link and finishes creating the account. Holds the connection open for about 60 seconds and returns **204 No Content** if they have not finished yet. **Retry on 204 and nothing else.** The call already blocks for you, so add no sleep between attempts. Every other status is final and retrying will not change the answer: 401 means the token is wrong, 410 means the link expired. Both carry `"terminal": true` in the body. A loop written as "retry until 200" spins at network speed against those, because they answer instantly rather than holding the connection. On completion it returns your `api_key` — **delivered exactly once**. Store it before doing anything else; a later poll returns the account without it. By that point the human is on their dashboard, their agent wallet is provisioned, and you are already recorded as their connected agent, so `announceAgentConnection` is not needed on this path.
Input schema 
{'type': 'object', 'required': ['claim_token', 'claim_code'], 'properties': {'claim_code': {'type': 'string', 'description': 'The claim_code from the same POST /signup response.'}, 'claim_token': {'type': 'string', 'description': 'The claim_token from POST /signup.'}}}
get_version
Get the current docs version Returns the current content-hash version of the Laso Finance agent docs (`SKILL.md`, `openapi.json`, `llms.txt`, `llms-full.txt`, `ai-plugin.json`). Free, no auth or payment header. Agents aggressively cache these docs, so use this to detect a stale cache: if the `docs_version` you last saw differs from the value returned here, refetch the docs. Every API response also carries this value in the `X-Laso-Docs-Version` response header, alongside `X-Laso-Docs-Manifest`, which points at the authoritative freshness beacon at `https://laso.finance/.well-known/docs-version.json`. This route is also the `status` target of the API catalog at `https://laso.finance/.well-known/api-catalog` (RFC 9727), which every response advertises via a `Link` header with `rel="api-catalog"`.
Input schema 
{'type': 'object', 'properties': {}}
get_webhook
Get webhook registration & delivery health (free) Returns the calling wallet's webhook registration and its delivery health. The signing secret is never returned here — it is shown once by `POST /register-webhook`; re-register to rotate it. A registration is auto-disabled after 50 consecutive failed deliveries (`disabled` becomes `true`); re-register to re-enable it.
Input schema 
{'type': 'object', 'properties': {'auth_token': {'type': 'string', 'description': 'Laso credential. Only if the MCP connection has no Authorization header.'}}}
get_withdrawal_status
Get withdrawal statuses Returns the status of withdrawals for the authenticated user. If `withdrawal_id` is provided, returns a single withdrawal. If omitted, returns all withdrawals.
Input schema 
{'type': 'object', 'properties': {'auth_token': {'type': 'string', 'description': 'Laso credential. Only if the MCP connection has no Authorization header.'}, 'withdrawal_id': {'type': 'string', 'description': 'Get a specific withdrawal by ID. If omitted, returns all withdrawals.'}}}
list_address_book
List saved recipients The saved recipient names your human manages on their dashboard, so a request like "send $20 to the coffee vendor" can be resolved to an address instead of asking them for it. Free. It operates only on the authenticated account's own book — there is no user parameter to pass. **A name is a label, not an instruction.** `agentWalletTransfer` takes an address and deliberately does not accept a name: a rename between your human asking and you sending would otherwise move money somewhere they did not intend. When you resolve a name to an address, say the address back to them before sending.
Input schema 
{'type': 'object', 'properties': {'auth_token': {'type': 'string', 'description': 'Laso credential. Only if the MCP connection has no Authorization header.'}}}
list_banking_accounts
List banking accounts Lists the account's banking rails and their details — for an on-ramp, the routing and account numbers to give whoever is paying in. The off-ramp deposit address is deliberately withheld: it is internal payout plumbing, not account detail. Free.
Input schema 
{'type': 'object', 'properties': {'auth_token': {'type': 'string', 'description': 'Laso credential. Only if the MCP connection has no Authorization header.'}}}
list_banking_recipients
List recipients and destinations Lists payout recipients and their destinations, with account numbers masked to the last four digits. This is where `destination_id` values come from. Also available as the free paywalled route `GET /bank-recipients`. Free.
Input schema 
{'type': 'object', 'properties': {'auth_token': {'type': 'string', 'description': 'Laso credential. Only if the MCP connection has no Authorization header.'}}}
list_banking_transactions
List transactions Lists banking transactions for the account: money arriving over the on-ramp and paying out over the off-ramp, with normalized statuses and amounts. Free.
Input schema 
{'type': 'object', 'properties': {'auth_token': {'type': 'string', 'description': 'Laso credential. Only if the MCP connection has no Authorization header.'}}}
list_bank_recipients
List bank payout recipients (free) Lists the recipients registered on your banking profile and the destinations attached to each, so you can find the `destination_id` that `GET /send-bank-payment` pays out to. Free — only the payout itself is a paid action. Bank account numbers are returned masked to their last four digits; routing numbers are returned in full. Create recipients and destinations with the `createBankingRecipient` and `addBankingDestination` callables, rename a destination's `nickname` (the only editable field) with `updateBankingDestination`, and remove a recipient with `deleteBankingRecipient` (see the [bank accounts guide](/guides/agent-bank-accounts)).
Input schema 
{'type': 'object', 'properties': {'auth_token': {'type': 'string', 'description': 'Laso credential. Only if the MCP connection has no Authorization header.'}}}
list_card_transactions
List reloadable card transactions Returns transactions on the authenticated user's **reloadable** cards, newest first: amount, merchant, status, and timestamps. Pass `card_id` for one card's history, or omit it for every reloadable card on the account. Filter with `status` and cap the page with `limit`. This route covers reloadable cards only. The two non-reloadable products keep their history in Laso's own records and are read through `/get-card-data`. If the wallet has no card issuer account linked, the list is empty and a `note` explains how the account holder sets one up at https://laso.finance/agent/dashboard/verified/card.
Input schema 
{'type': 'object', 'properties': {'limit': {'type': 'number', 'description': "Maximum number of transactions to return. Defaults to the issuer's own page size (20)."}, 'status': {'type': 'string', 'description': 'Filter by status, e.g. `pending`, `settled`, `declined`, `reversed`, `refunded`.'}, 'card_id': {'type': 'string', 'description': "Return only this card's transactions. Omit for every reloadable card on the account."}, 'auth_token': {'type': 'string', 'description': 'Laso credential. Only if the MCP connection has no Authorization header.'}}}
list_payment_recipients
List saved Venmo and PayPal recipients (free) Lists the Venmo or PayPal recipients this account has paid before, so you can resolve a name your human said ("send $20 to Jane") into the `handle` that `GET /send-payment` takes as its `recipient_id`. Free — only the payout itself is a paid action. Two different ids are in play. Each entry's `recipient_id` is an opaque saved-entry id: pass it to `POST` and `DELETE /payment-recipients`. Its `handle` is the phone number or email you actually pay: pass that as `recipient_id` to `GET /send-payment`. Passing the saved-entry id to `GET /send-payment` does not send to the saved person. Use `total_sent` and `last_sent_timestamp` to disambiguate similar names, and confirm with your human rather than guessing between two entries.
Input schema 
{'type': 'object', 'required': ['platform'], 'properties': {'platform': {'enum': ['venmo', 'paypal'], 'type': 'string', 'description': 'Payment platform whose saved recipients to list.'}, 'auth_token': {'type': 'string', 'description': 'Laso credential. Only if the MCP connection has no Authorization header.'}, 'include_archived': {'enum': ['true', 'false'], 'type': 'string', 'description': 'Include archived entries. Defaults to false.'}}}
order_gift_card
Order a gift card Pay USDC via x402 to order a gift card. First browse the catalog via `GET /search-gift-cards` to find the `laso_server_id` for the card you want, then call this endpoint with the amount and product ID. **Pricing:** `amount` is the card's face value in the product's own currency, not USD. Laso converts it to USD at the current exchange rate and adds the product's fee (up to 4.8%); that total is the x402 USDC price. A 100 SAR card costs roughly $28 USDC, not $100. Check the product's `currency` field in `GET /search-gift-cards` to see what `amount` is denominated in. The $5 minimum and $9,000 maximum apply to the **converted USD value**, not the raw amount, so a foreign-currency amount is accepted only when its USD equivalent falls inside that range. Returns redemption details (URL, code, and/or PIN) depending on the gift card brand. PAID ROUTE (5-9432 USD): the x402 USDC price is paid automatically from your managed agent wallet. Make sure the wallet exists and is funded first (get_agent_wallet).
Input schema 
{'type': 'object', 'required': ['amount', 'laso_server_id'], 'properties': {'amount': {'type': 'number', 'description': "Gift card face value in the product's own currency (see the product's `currency` field in `GET /search-gift-cards`), not USD. The x402 price is this value converted to USD plus the product fee. After conversion it must be worth at least $5 and at most $9,000 USD.", 'exclusiveMinimum': 0}, 'country': {'type': 'string', 'default': 'US', 'description': 'ISO 3166-1 alpha-2 country code (defaults to "US")'}, 'auth_token': {'type': 'string', 'description': 'Laso credential. Only if the MCP connection has no Authorization header.'}, 'laso_server_id': {'type': 'string', 'description': 'The product identifier from the gift card catalog (GET /search-gift-cards). Always copy it from a search result; an id that is not in the catalog returns 404 `unknown_laso_server_id`. Amazon is `amazon` for every country, selected with `country`.'}}}
order_intl_card
Order an international prepaid card Order an international non-reloadable prepaid card (USD). The order is queued and fulfilled by an admin — after fulfillment, card details become available via `GET /get-card-data` with `card_type=Non-Reloadable International`. The x402 payment covers the on-card amount plus a 3.8% fee. Minimum $100, maximum $1,000 on-card amount. Submit a whole dollar amount. Placing the order accepts the card issuer's terms on behalf of the account holder: the [Cardholder Agreement](https://laso.finance/intl-card-cardholder-agreement.pdf), the [E-Communications Disclosure](https://laso.finance/intl-card-e-communications-disclosure.pdf), and the [Privacy Notice](https://laso.finance/intl-card-privacy-notice.pdf). If you need to cancel a queued order before it is fulfilled, use `POST /cancel-intl-order`. PAID ROUTE (103.80-1038 USD): the x402 USDC price is paid automatically from your managed agent wallet. Make sure the wallet exists and is funded first (get_agent_wallet).
Input schema 
{'type': 'object', 'required': ['amount'], 'properties': {'amount': {'type': 'number', 'maximum': 1000, 'minimum': 100, 'description': 'On-card USD amount (min $100, max $1,000). Must be a whole dollar amount: the issuer only issues whole-dollar cards. The x402 payment is this amount plus a 3.8% fee.'}, 'auth_token': {'type': 'string', 'description': 'Laso credential. Only if the MCP connection has no Authorization header.'}}}
pay_x402_endpoint
Pay ANY external x402-paywalled endpoint from your managed agent wallet: the target's 402 challenge is settled in USDC and the response body is returned, with the settlement transaction as txHash. The wallet balance can take up to a minute to reflect a payment, so confirm with txHash rather than an immediate balance read. Use the guardrail arguments to pin what you agreed to pay. For Laso's own paid routes, prefer their dedicated tools instead.
Input schema 
{'type': 'object', 'required': ['url'], 'properties': {'url': {'type': 'string', 'description': 'Full https URL of the x402 endpoint to call and pay.'}, 'body': {'type': 'object', 'description': 'JSON request body (for POST/PUT).'}, 'method': {'type': 'string', 'description': 'HTTP method (default GET).'}, 'params': {'type': 'object', 'description': 'Query parameters to append to the URL.'}, 'auth_token': {'type': 'string', 'description': 'Laso credential. Only if the MCP connection has no Authorization header.'}, 'expected_asset': {'type': 'string', 'description': 'Refuse to settle in any other asset (e.g. a USDC mint/contract address).'}, 'expected_pay_to': {'type': 'string', 'description': 'Refuse to settle to any other receiving address.'}, 'max_amount_usdc': {'type': 'number', 'description': 'Refuse to settle if the endpoint asks for more USDC than this.'}, 'expected_network': {'type': 'string', 'description': 'Refuse to settle on any other network (CAIP-2 id).'}}}
push_to_card
Send money to a debit card (USD, EUR, GBP) Pay USDC to initiate a push-to-card transfer. Specify the face value in the target currency (USD, EUR, or GBP); Laso computes the USDC cost using the current exchange rate plus a 4.8% fee (minimum fee of $1.50/€1.50/£1.50 in the transfer currency), and that becomes the x402 price. Returns a `redemption_url` that must be opened to complete the transfer. The form requires sender name, debit card number, and cardholder name. **Supported currencies:** - `USD` — U.S. debit cards (U.S. bank accounts only) - `EUR` — Eurozone debit cards - `GBP` — U.K. debit cards Laso cannot perform the transfer directly — the redemption URL must be visited and the debit card details entered manually (by the agent or a human). **Fee:** 4.8%, with a minimum of 1.50 in the transfer currency (included in the USDC price, computed from the requested face value). PAID ROUTE (11.50-10000 USD): the x402 USDC price is paid automatically from your managed agent wallet. Make sure the wallet exists and is funded first (get_agent_wallet).
Input schema 
{'type': 'object', 'required': ['amount'], 'properties': {'amount': {'type': 'number', 'maximum': 9541.98, 'minimum': 10, 'description': 'Face value to send to the debit card, denominated in the chosen `currency` (min 10, max 9,541.98). The x402 payment price is this face value converted to USD plus a 4.8% fee (minimum fee of 1.50 in the chosen currency).'}, 'currency': {'enum': ['USD', 'EUR', 'GBP'], 'type': 'string', 'default': 'USD', 'description': 'Target currency for the debit card transfer. Defaults to `USD`.'}, 'auth_token': {'type': 'string', 'description': 'Laso credential. Only if the MCP connection has no Authorization header.'}}}
refresh_card_data
Trigger a card data refresh Requests an updated balance for a card. For U.S. non-reloadable cards (default), the card is re-scraped from the issuer via a retrieval queue and processed asynchronously. Rate limited per card to one request every 5 minutes, and to at most 12 refreshes in any rolling 24-hour period. For international non-reloadable cards, a balance update request is recorded; an admin will manually update the balance within 24 hours. While a balance update is already pending for a card, additional requests for that card return 409.
Input schema 
{'type': 'object', 'required': ['card_id'], 'properties': {'card_id': {'type': 'string', 'description': 'The card ID to refresh data for'}, 'card_type': {'enum': ['Non-Reloadable U.S.', 'Non-Reloadable International'], 'type': 'string', 'description': 'The type of card. Defaults to `Non-Reloadable U.S.` if omitted.'}, 'auth_token': {'type': 'string', 'description': 'Laso credential. Only if the MCP connection has no Authorization header.'}}}
refresh_token
Refresh an ID token Exchange a refresh token for a new ID token. This is a free endpoint — no x402 payment required. Uses the standard OAuth2 `grant_type=refresh_token` pattern.
Input schema 
{'type': 'object', 'required': ['grant_type', 'refresh_token'], 'properties': {'grant_type': {'enum': ['refresh_token'], 'type': 'string', 'description': 'Must be "refresh_token"'}, 'refresh_token': {'type': 'string', 'description': 'The refresh token received from a previous /auth or /get-card call'}}}
register_webhook
Register a notification webhook (free) Registers (or replaces) an HTTPS webhook URL to receive the calling wallet's account notifications as signed POSTs — banking application status changes, bank transfer and payout completions, agent wallet deposits, card orders, and every other event the user is notified about. This closes the polling gap for agents: instead of re-fetching status endpoints, point this at any URL you can receive HTTP on (your harness's inbound webhook endpoint, or a relay you poll). Deliveries are signed per the Standard Webhooks specification (https://www.standardwebhooks.com/): each POST carries `webhook-id`, `webhook-timestamp`, and `webhook-signature` (`v1,<base64 HMAC-SHA256>`) headers verifiable with any standard-webhooks library using the returned `secret`. The body is `{"type": "notification.<category>", "timestamp": "<ISO 8601>", "data": {"user_id", "title", "text", "category"}}`. The `secret` is returned exactly once, by this call. Re-registering rotates the secret, replaces the URL, and re-enables a registration that was auto-disabled after 50 consecutive failed deliveries. Registering also notifies the account owner through their other channels and fires a first signed test delivery (`type` `notification.account`) at the new URL. Deliveries time out after 10 seconds and are not retried; treat the webhook as a low-latency hint and the status endpoints as the source of truth. The URL must be public HTTPS.
Input schema 
{'type': 'object', 'required': ['url'], 'properties': {'url': {'type': 'string', 'description': 'Public HTTPS URL to receive signed notification POSTs. Max 512 characters. Private/internal hosts are rejected.'}, 'auth_token': {'type': 'string', 'description': 'Laso credential. Only if the MCP connection has no Authorization header.'}}}
save_address_book_entry
Save or rename a recipient The saved recipient names your human manages on their dashboard, so a request like "send $20 to the coffee vendor" can be resolved to an address instead of asking them for it. Free. It operates only on the authenticated account's own book — there is no user parameter to pass. **A name is a label, not an instruction.** `agentWalletTransfer` takes an address and deliberately does not accept a name: a rename between your human asking and you sending would otherwise move money somewhere they did not intend. When you resolve a name to an address, say the address back to them before sending. The address is the entry's key, so saving one that is already saved renames it rather than creating a duplicate. That makes this safe to retry.
Input schema 
{'type': 'object', 'required': ['address', 'name'], 'properties': {'name': {'type': 'string', 'example': 'Coffee vendor', 'description': 'The name to save it under. Sanitized and capped server-side (max 60 characters).'}, 'address': {'type': 'string', 'example': '7xKXtg2CW87d97TXJSDpbD5jBkheTqA83TZRuJosgAsU', 'description': "The recipient's Solana address."}, 'auth_token': {'type': 'string', 'description': 'Laso credential. Only if the MCP connection has no Authorization header.'}}}
search_docs
Search the Laso Finance agent docs (SKILL.md and the full API reference). Returns the most relevant sections. Use this for anything the tool descriptions don't answer: auth flows, funding, fees, webhooks, error handling.
Input schema 
{'type': 'object', 'required': ['query'], 'properties': {'query': {'type': 'string', 'description': 'Search terms, e.g. fund managed wallet, or: gift card fees.'}}}
search_gift_cards
Search the gift card catalog Browse and search available gift cards. Returns a list of gift card products with pricing, denomination, and catalog information. Use the `laso_server_id` from the results to order a card via `GET /order-gift-card`. Every response includes a `facets` object listing the valid values for the `category`, `currency`, and `country` filters. The facets are computed from the full catalog, so a single unfiltered request (no query parameters) is enough to discover everything you can filter on. This is a free endpoint — no x402 payment required.
Input schema 
{'type': 'object', 'properties': {'q': {'type': 'string', 'description': 'Search query to filter gift cards by name (e.g. "Amazon", "Uber")'}, 'country': {'type': 'string', 'description': 'ISO 3166-1 alpha-2 country code to filter by (e.g. "US", "GB"). Returns gift cards available in that country, including borderless products that have no country restriction.'}, 'category': {'type': 'string', 'description': 'Category to filter by (e.g. "ecommerce", "travel", "gaming"). See the `facets.categories` array in any response for the full list of valid values.'}, 'currency': {'type': 'string', 'description': 'Currency code to filter by (e.g. "USD", "EUR")'}, 'auth_token': {'type': 'string', 'description': 'Laso credential. Only if the MCP connection has no Authorization header.'}}}
search_merchants
Search merchant spend data Search Laso's merchant database for confirmed spend data for a given card type. Returns whether the card was accepted, not accepted, or unknown at each merchant. Use `card_type` to search by the USA prepaid card (`Non-Reloadable U.S.`, the default) or the international prepaid card (`Non-Reloadable International`). USA searches exclude merchants with non-US country-code TLDs; international searches do not. **Important:** This database only contains merchants where Laso users have previously attempted a transaction. A merchant not being listed, or being listed as `unknown`, does NOT mean the card won't work there — it just means it hasn't been tried yet. If a merchant is listed as `accepted`, you can confidently use the card there. If listed as `not_accepted`, the card will fail at that merchant. Banking and money-transfer merchants are always returned as `not_accepted` with a `restriction_note`, whatever the transaction history shows. Spending there counts as a transfer of value and is not supported on any card.
Input schema 
{'type': 'object', 'required': ['q'], 'properties': {'q': {'type': 'string', 'description': 'Search query — the merchant name to search for (e.g. "amazon", "netflix")'}, 'card_type': {'enum': ['Non-Reloadable U.S.', 'Non-Reloadable International'], 'type': 'string', 'default': 'Non-Reloadable U.S.', 'description': 'Which card type to search acceptance for. Defaults to `Non-Reloadable U.S.` if omitted (preserves existing client behavior). Pass `Non-Reloadable International` to search for international prepaid card acceptance.'}, 'auth_token': {'type': 'string', 'description': 'Laso credential. Only if the MCP connection has no Authorization header.'}}}
send_bank_payment
Send dollars to a bank account Pay USDC to send dollars to a bank account by ACH. The x402 USDC price is the requested amount plus a 0.25% transfer fee (with a $1.50 minimum fee). On-chain payment credits the calling wallet's Laso account balance via the standard deposit webhook; the callable then debits the gross amount and queues the transfer. **A bank destination is required first.** `destination_id` comes from the banking callables: create the banking profile with `createBankingProfile`, register who is being paid with `createBankingRecipient`, and attach their bank account with `addBankingDestination`, which returns the id. List what you already have at `GET /bank-recipients` (free). See the [bank accounts guide](/guides/agent-bank-accounts) for the full setup. **Identity verification is required** on the account that owns the banking profile, and only the human owner can complete it. `createBankingProfile` hands back a `kycUrl` when it is outstanding. **If the payout cannot be fulfilled** (no approved banking profile, a destination that is not yours, an amount out of range), nothing is stranded: the USDC you paid has already credited your account balance. Fix the problem and retry, or recover it with `POST /withdraw`. **Settlement:** ACH, normally 1-2 business days. Follow it with `listBankingTransactions` / `getBankingTransaction`. **Fee:** 0.25% with a $1.50 minimum (included in the USDC price). PAID ROUTE (11.50-10025 USD): the x402 USDC price is paid automatically from your managed agent wallet. Make sure the wallet exists and is funded first (get_agent_wallet).
Input schema 
{'type': 'object', 'required': ['amount', 'destination_id'], 'properties': {'amount': {'type': 'number', 'maximum': 50000, 'minimum': 10, 'description': "USD delivered to the recipient's bank account (min $10, max $50,000). The x402 payment price is this amount plus a 0.25% fee (with a $1.50 minimum)."}, 'auth_token': {'type': 'string', 'description': 'Laso credential. Only if the MCP connection has no Authorization header.'}, 'destination_id': {'type': 'string', 'description': 'Bank destination to pay out to. Returned by `addBankingDestination`, and listed by `GET /bank-recipients`.'}}}
send_feedback
Send feedback about the API Tell the humans running Laso what worked, what was confusing, and what you wish existed. It lands on their dashboard, so it is the best channel for API friction and feature requests. Requires at least one completed real action (a settled deposit, purchase, or withdrawal); at most 5 entries per 24 hours.
Input schema 
{'type': 'object', 'required': ['feedback'], 'properties': {'rating': {'type': 'integer', 'example': 4, 'maximum': 5, 'minimum': 1, 'description': 'A 1-5 satisfaction rating. Optional; ignored when not an integer in range.'}, 'endpoint': {'type': 'string', 'example': '/order-intl-card', 'description': 'Which API endpoint or route the feedback is about. Optional. Capped at 120 characters.'}, 'feedback': {'type': 'string', 'example': 'order-intl-card was smooth but I wanted a way to see the fee before paying', 'description': 'The main free-text feedback. Required. Sanitized and capped server-side (max 2000 characters).'}, 'auth_token': {'type': 'string', 'description': 'Laso credential. Only if the MCP connection has no Authorization header.'}, 'how_it_went': {'type': 'string', 'example': 'worked, minor confusion on fees', 'description': 'How it went. Optional. Capped at 500 characters.'}, 'what_they_want': {'type': 'string', 'example': 'order an international card', 'description': 'What you were trying to do. Optional. Capped at 500 characters.'}}}
send_payment
Send a payment via Venmo or PayPal Pay USDC to send money to a Venmo or PayPal recipient. The x402 USDC price is the requested amount plus a 4.9% fee (with a $1.50 minimum fee). On-chain payment credits the calling wallet's Laso account balance via the standard deposit webhook; the callable then debits the gross amount and dispatches the payout. **KYC required.** The first time a wallet sends a Venmo or PayPal payout it must complete identity verification. If the wallet is not yet verified the response returns `kyc_required: true` and a `kyc_url` — open the URL, complete the flow, and retry. If you don't want to proceed, the credited account balance can be withdrawn with `POST /withdraw`. **Recipient details.** Both Venmo and PayPal require the recipient's first name and last name. For Venmo, `recipient_id` is the recipient's 10-digit U.S. phone number and `recipient_email` is required. For PayPal, `recipient_id` is the recipient's PayPal email, which also serves as `recipient_email` (so `recipient_email` is optional). **Fee:** 4.9% with a $1.50 minimum (included in the USDC price). PAID ROUTE (6.50-1049 USD): the x402 USDC price is paid automatically from your managed agent wallet. Make sure the wallet exists and is funded first (get_agent_wallet).
Input schema 
{'type': 'object', 'required': ['amount', 'platform', 'recipient_id', 'recipient_first_name', 'recipient_last_name'], 'properties': {'amount': {'type': 'number', 'maximum': 1000, 'minimum': 5, 'description': 'USD amount to send to the recipient (min $5, max $1,000). The x402 payment price is this amount plus a 4.9% fee (with a $1.50 minimum).'}, 'platform': {'enum': ['venmo', 'paypal'], 'type': 'string', 'description': 'Payment platform.'}, 'auth_token': {'type': 'string', 'description': 'Laso credential. Only if the MCP connection has no Authorization header.'}, 'recipient_id': {'type': 'string', 'description': 'Recipient identifier. For Venmo: 10-digit U.S. phone number. For PayPal: email address.'}, 'recipient_email': {'type': 'string', 'format': 'email', 'description': "Recipient's email address. Required for Venmo. Optional for PayPal, where it defaults to recipient_id (the PayPal email)."}, 'recipient_last_name': {'type': 'string', 'description': "Recipient's last name (English letters A-Z and a-z only)."}, 'recipient_first_name': {'type': 'string', 'description': "Recipient's first name (English letters A-Z and a-z only)."}}}
start_signup
Start a signup for a human with no Laso account Begins account creation for a human who does not have a Laso account yet. Requires no authentication, because the caller has no account. This does **not** create the account. An agent cannot: the account is created by Privy in the human's own browser, so it belongs to them and not to their agent. What this returns is a `claim_url` to hand over. Give your human the `claim_url` verbatim in your very next reply (send `message_for_human` if unsure what to say), and do not open it yourself. Then poll `GET /signup-status`, which holds the connection open until they finish and hands you your `lasoak_` API key. Rate limited per IP.
Input schema 
{'type': 'object', 'properties': {'label': {'type': 'string', 'example': 'ada-prod', 'description': 'Optional label recorded on the minted API key so your human can tell keys apart.'}, 'agent_name': {'type': 'string', 'example': 'Ada', 'description': 'Your name, shown to your human on the claim screen and recorded as the connected agent.'}}}
submit_banking_application
Submit the application Submits the completed application for review. If the partner rejects it as incomplete, the reply says what is still missing rather than failing opaquely. Free.
Input schema 
{'type': 'object', 'properties': {'auth_token': {'type': 'string', 'description': 'Laso credential. Only if the MCP connection has no Authorization header.'}}}
update_banking_application_details
Answer application questions Submits answers to the non-identity application questions read from `getBankingApplication`. Call as many times as needed; each call merges. Free.
Input schema 
{'type': 'object', 'required': ['details'], 'properties': {'details': {'type': 'object', 'description': 'The answers to submit, keyed by the field names `getBankingApplication` reported as outstanding.'}, 'auth_token': {'type': 'string', 'description': 'Laso credential. Only if the MCP connection has no Authorization header.'}}}
update_banking_destination
Rename a destination Sets or clears a destination's nickname. This is the only editable field: bank details are immutable at the partner, so anything else wrong means deleting the recipient and creating a new one. Free.
Input schema 
{'type': 'object', 'required': ['destinationId', 'nickname'], 'properties': {'nickname': {'type': 'string', 'example': 'Rent account', 'description': 'The new nickname. An empty string clears it.'}, 'auth_token': {'type': 'string', 'description': 'Laso credential. Only if the MCP connection has no Authorization header.'}, 'destinationId': {'type': 'string', 'description': 'The destination to rename.'}}}
update_payment_recipient
Rename or archive a saved recipient (free) Renames a saved Venmo or PayPal recipient, archives it, or both. Provide at least one of `display_name` or `archived`. Archiving hides an entry from the default list while keeping its history, which is the reversible way to retire a recipient. Prefer it over `DELETE`.
Input schema 
{'type': 'object', 'required': ['platform', 'recipient_id'], 'properties': {'archived': {'type': 'boolean', 'description': 'Must be a boolean. A wrong type returns a terminal 400 with code `invalid_archived`.'}, 'platform': {'enum': ['venmo', 'paypal'], 'type': 'string', 'description': 'Payment platform the recipient is saved under.'}, 'auth_token': {'type': 'string', 'description': 'Laso credential. Only if the MCP connection has no Authorization header.'}, 'display_name': {'type': 'string', 'description': 'Must be a string. A wrong type returns a terminal 400 with code `invalid_display_name`.'}, 'recipient_id': {'type': 'string', 'description': "The entry's `recipient_id` from `GET /payment-recipients` (an opaque id, not the phone number or email)."}}}
upload_banking_document
Upload a proof-of-address document Attaches a proof-of-address document to the banking application, for the cases where the partner asks for one. The application must already exist and have an individual on it, so complete the application first. **Two things reject uploads that otherwise look fine.** A `.jpg` file must be sent as `fileType: "jpeg"` — `"jpg"` is refused. And the partner caps the *decoded* size at 10MB, even though their own upload page advertises 20MB; oversized files are rejected here before the round-trip. `fileContent` accepts either a bare base64 string or a `data:` URL, so a browser `FileReader.readAsDataURL` result can be passed through unchanged. Free.
Input schema 
{'type': 'object', 'required': ['documentType', 'fileType', 'fileContent', 'country'], 'properties': {'country': {'type': 'string', 'example': 'US', 'description': "The document's country, ISO 3166-1 alpha-2."}, 'fileType': {'enum': ['pdf', 'jpeg', 'png'], 'type': 'string', 'example': 'jpeg', 'description': "The file's format. Send a .jpg as `jpeg`."}, 'filename': {'type': 'string', 'example': 'utility-bill.pdf', 'description': "The file's name."}, 'auth_token': {'type': 'string', 'description': 'Laso credential. Only if the MCP connection has no Authorization header.'}, 'fileContent': {'type': 'string', 'description': 'The file, base64-encoded. A `data:` URL is also accepted. Decoded size must be 10MB or less.'}, 'documentType': {'enum': ['proof_of_address', 'bank_statement', 'utility_bill'], 'type': 'string', 'example': 'utility_bill', 'description': 'The kind of document.'}}}
withdraw
Withdraw from account balance Initiate a withdrawal from the user's account balance. The USDC is sent on Solana to the `solana_address` you supply; the destination is never inferred, so the address is required. The withdrawal is created in a `pending` state and sent within a few minutes.
Input schema 
{'type': 'object', 'required': ['amount', 'solana_address'], 'properties': {'amount': {'type': 'number', 'minimum': 0.01, 'description': 'Amount to withdraw in USD'}, 'auth_token': {'type': 'string', 'description': 'Laso credential. Only if the MCP connection has no Authorization header.'}, 'solana_address': {'type': 'string', 'description': 'Solana wallet address that receives the USDC. Must be a valid base58 Solana address.'}}}
withdraw_card_balance
Withdraw from a reloadable card balance Move unspent money off the account holder's reloadable card. The balance behind a reloadable card is held by the card issuer, and this asks the issuer to pay `amount` of it out as USDC on **Base** to the `destination_address` you supply. It is the reverse of `GET /fund-card-balance`, and free: the money is the holder's own, and Laso moves nothing itself. **Base only.** The issuer pays on Base and nowhere else, so the destination must be a Base wallet you control. A Laso managed agent wallet holds USDC on **Solana** and cannot receive this. The card deposit address from `GET /get-card-deposit-address` is not a valid destination either. **Not instant.** The issuer processes payouts manually, usually within 1-3 business days, and emails the account holder when the payout is sent. The response carries the issuer's `withdrawal_id`; there is no status route to poll. The request is recorded as a `withdrawal` event under `card_events` in `GET /list-card-transactions`, and the balance from `GET /get-card-deposit-address` drops once it is paid. **Amount:** $2 to $10,000, and no more than the balance the issuer can release. Withdrawals the issuer has not paid yet still count against the balance, so a second request can only take what remains. Confirm the amount and destination with the account holder before calling this. A linked card issuer account is required; the holder sets it up at https://laso.finance/agent/dashboard/verified/card.
Input schema 
{'type': 'object', 'required': ['amount', 'destination_address'], 'properties': {'amount': {'type': 'number', 'maximum': 10000, 'minimum': 2, 'description': 'USD to withdraw from the card balance (min $2, max $10,000).'}, 'auth_token': {'type': 'string', 'description': 'Laso credential. Only if the MCP connection has no Authorization header.'}, 'destination_address': {'type': 'string', 'description': 'The 0x-prefixed Base wallet address that receives the USDC. Must be one you control; Base only.'}}}
History

Recent tool changes

Added
search_docs
Sept. 27, 2026, 2:40 a.m.
Added
pay_x402_endpoint
Sept. 27, 2026, 2:40 a.m.
Added
agent_wallet_transfer
Sept. 27, 2026, 2:40 a.m.
Added
create_agent_wallet
Sept. 27, 2026, 2:40 a.m.
Added
get_agent_wallet
Sept. 27, 2026, 2:40 a.m.
Added
announce_connection
Sept. 27, 2026, 2:40 a.m.
Added
create_agent_api_key
Sept. 27, 2026, 2:40 a.m.
Added
get_agent_spend_limit
Sept. 27, 2026, 2:40 a.m.
Added
exchange_api_key
Sept. 27, 2026, 2:40 a.m.
Added
list_banking_transactions
Sept. 27, 2026, 2:40 a.m.
Added
get_banking_transaction
Sept. 27, 2026, 2:40 a.m.
Added
delete_banking_recipient
Sept. 27, 2026, 2:40 a.m.
Added
update_banking_destination
Sept. 27, 2026, 2:40 a.m.
Added
list_banking_recipients
Sept. 27, 2026, 2:40 a.m.
Added
add_banking_destination
Sept. 27, 2026, 2:40 a.m.
Added
create_banking_recipient
Sept. 27, 2026, 2:40 a.m.
Added
list_banking_accounts
Sept. 27, 2026, 2:40 a.m.
Added
create_banking_account
Sept. 27, 2026, 2:40 a.m.
Added
submit_banking_application
Sept. 27, 2026, 2:40 a.m.
Added
upload_banking_document
Sept. 27, 2026, 2:40 a.m.
Added
update_banking_application_details
Sept. 27, 2026, 2:40 a.m.
Added
get_banking_application
Sept. 27, 2026, 2:40 a.m.
Added
get_banking_profile_status
Sept. 27, 2026, 2:40 a.m.
Added
create_banking_profile
Sept. 27, 2026, 2:40 a.m.
Added
order_gift_card
Sept. 27, 2026, 2:40 a.m.
Added
search_gift_cards
Sept. 27, 2026, 2:40 a.m.
Added
list_bank_recipients
Sept. 27, 2026, 2:40 a.m.
Added
send_bank_payment
Sept. 27, 2026, 2:40 a.m.
Added
get_payment_status
Sept. 27, 2026, 2:40 a.m.
Added
delete_payment_recipient
Sept. 27, 2026, 2:40 a.m.
Discover

Similar MCP servers

SAP MCP Server

ai.oobeprotocol.sap.mcp/sap-mcp

Provides an MCP gateway connecting SAP-related tools with Solana, DeFi, decentralized identity, and x402 payments.

FortFi Treasury MCP

io.github.rebelArtists/fortfi-treasury-mcp

Provides policy-controlled crypto treasury operations across chains, including wallets, payments, token discovery, swaps, bridges…

DPX — Institutional Cross-Border Settlement

io.github.untitledfinancial/dpx

Provides compliance-gated cross-border crypto settlement, agent registration and spending mandates, stablecoin routing, ESG and s…

Peer

io.github.zkp2p/peer

Reads Peer protocol, checkout, deposit, wallet, Peer Cash, cross-chain routing, payout, and IntentGuardian data on Base and relat…

Robyn — Gasless Cross-Chain for AI Agents

io.github.ox31461/robyn

Supports gasless cross-chain transfers, wallet and transaction checks, spending mandates, privacy-preserving messaging, and signe…

MERX - TRON Resource Exchange

exchange.merx/mcp

Manages TRON energy and bandwidth purchasing, resource monitoring, transaction cost estimation, wallet operations, token transfer…

Wisely x402 Agent-Payment Infrastructure

com.wiselyenterprisesllc/x402-agent-payment-infrastructure

Provides agent payment workflows for x402 endpoints, wallet handoffs, receipts, creator catalogs, local commerce bridges, endpoin…

AgentTools Hub

io.github.Thyphex/agenttools-hub

Offers calculators, unit and data converters, reference lookups, live crypto data, wallet utilities, and paid x402 access.