> **Can't find what you're looking for?** Use `search_docs` on the docs MCP server at `https://mpp.dev/api/mcp` to find what you need. # Wallets \[Give your agent a wallet] Agents need a wallet to pay for MPP-enabled services. Choose the wallet that fits your use case best. | Wallet | Best for | Supported methods | Setup | |--------|----------|-------------------|-------| | [Tempo Wallet](#tempo-wallet) | Tempo MPP services with spend controls and service discovery | `tempo` | `tempo wallet login` | | [Privy Agent CLI](#privy-agent-cli) | Multi-chain agent wallets with browser-based funding | `tempo`, `solana` | `privy-agent-wallets login` | | [AgentCash](#agentcash) | Discover and use 300+ premium APIs via MPP | `tempo` | `npx agentcash onboard` | | [Link CLI](#link-cli) | Stripe payments via Link wallet | `stripe` | `link-cli auth login` | | [Kite Passport](#kite-passport) | Agent wallets with owner-set spend guardrails + multi-chain settlement | `tempo` | `kpass login init` | | [`mppx` CLI](#mppx) | Development and debugging | All | `mppx account create` | ## Tempo Wallet The [Tempo Wallet](https://wallet.tempo.xyz) is a managed MPP client with built-in spend controls and service discovery. Agents use `tempo wallet` to discovery and pay for MPP-enabled services on demand. Paste this into your agent: ``` Read https://tempo.xyz/SKILL.md and set up tempo ``` :::steps ### Install the CLI ```bash [terminal] $ curl -fsSL https://tempo.xyz/install | bash ``` ### Connect your wallet ```bash [terminal] $ tempo wallet login ``` ### Verify setup ```bash [terminal] $ tempo wallet whoami ``` ### List available services ```bash [terminal] $ tempo wallet services ``` ### Make a paid request ```bash [terminal] $ tempo request -X POST \ --json '{"prompt": "a sunset over the ocean"}' \ https://fal.mpp.tempo.xyz/fal-ai/flux/dev ``` ::: **Supported methods:** tempo.charge tempo.session **Key features:** * **Service discovery**—`tempo wallet services` lists endpoints, pricing, and request schemas * **Spend controls**—scoped access keys enforce per-key spending limits * **Dry-run previews**—`tempo request --dry-run` validates cost before committing funds * **Efficient output**—`-t` flag gives compact, machine-readable output for agent tooling ## Privy Agent CLI [Privy Agent CLI](https://docs.privy.io/recipes/agent-integrations/agent-cli) gives agents a CLI-first way to create, fund, and manage wallets with no integration code. It pairs with the [Privy Agent Sandbox](https://agents.privy.io/) where users track spending, manage funds, and revoke access. The agent never holds the wallet private key—each session generates a P-256 keypair used to sign authorization payloads. Paste this into your agent: ``` Set up https://agents.privy.io/skill.md ``` :::steps ### Install ```bash [terminal] $ npm install -g @privy-io/agent-wallet-cli ``` ### Log in ```bash [terminal] $ privy-agent-wallets login ``` This opens a browser flow—complete Privy auth, approve signer access, then paste the credential back into the terminal. ### Fund wallets ```bash [terminal] $ privy-agent-wallets fund ``` ### List wallets ```bash [terminal] $ privy-agent-wallets list-wallets ``` ### Send a transaction ```bash [terminal] $ privy-agent-wallets rpc --json '{"method": "eth_sendTransaction", "params": {"to": "0xRecipient", "value": "0.01"}}' ``` ::: **Supported methods:** tempo.charge tempo.session solana.charge **Key features:** * **No private key exposure**—each session generates a P-256 keypair; the agent signs authorization payloads, never holds the wallet key * **Browser-based funding**—the human owner retains a visual dashboard to check balances, view history, and onramp funds * **Session management**—sessions stored in the OS credential manager, expire after seven days, revocable from [agents.privy.io/manage](https://agents.privy.io/manage) ## AgentCash [AgentCash](https://agentcash.dev) gives agents instant access to 300+ premium APIs for data enrichment, social data, image generation, web scraping, email, and much more, all through one USDC.e balance. Paste this into your agent: ``` Set up agentcash.dev/skill.md ``` :::steps ### Onboard and get free credits Visit [agentcash.dev/onboard](https://agentcash.dev/onboard) to claim a sign-up bonus, then redeem in your terminal: ```bash [terminal] $ npx agentcash onboard ``` ### Search for services ```bash [terminal] $ npx agentcash search "image generation" ``` ### Use a service ```bash [terminal] $ npx agentcash fetch https://stableenrich.dev/api/exa/search \ --method POST \ --body '{"query":"agentcash.dev"}' ``` ### Install as MCP server (optional) ```bash [terminal] $ claude mcp add agentcash --scope user -- npx -y agentcash@latest ``` ::: **Supported methods:** tempo.charge **Key features:** * **300+ premium APIs** - enrichment, social data, image generation, web scraping, email, all accessible instantly * **No human required** - pay per request with USDC.e, no subscriptions or manual sign-up flows * **API and tool discovery** - any service that implements MPP is automatically discoverable and usable * **MPPScan integration** — easily discover and use services via [mppscan.com](https://www.mppscan.com/) ## Link CLI [Link CLI](https://github.com/stripe/link-cli) lets agents pay for MPP services using a [Link](https://link.co) wallet. The agent authenticates with Link, then `link-cli mpp pay` handles the full `402` → SPT → retry flow automatically—no Stripe integration code required. The user approves each purchase via the Link app, and Credentials are one-time-use tokens scoped to a specific merchant and amount. Paste this into your agent: ``` Read https://github.com/stripe/link-cli/blob/main/SKILL.md and set up link-cli ``` :::steps ### Install ```bash [terminal] $ npm install -g @stripe/link-cli ``` ### Log in ```bash [terminal] $ link-cli auth login --client-name "My Agent" ``` This displays a verification URL and phrase. Approve in the Link app to complete authentication. ### List payment methods ```bash [terminal] $ link-cli payment-methods list ``` ### Make a paid request ```bash [terminal] $ link-cli mpp pay https://api.example.com/resource \ --method POST \ --data '{"prompt": "hello"}' ``` ::: **Supported methods:** stripe.charge **Key features:** * **End-to-end 402 handling**—`link-cli mpp pay` parses the Challenge, creates an SPT, and retries with the Credential * **User approval**—each purchase requires explicit approval in the Link app * **One-time-use Credentials**—SPTs are scoped to a specific merchant, amount, and context * **MCP server mode**—run as `link-cli --mcp` for integration with Claude Code and other MCP-compatible agents ## Kite Passport [Kite Passport](https://agentpassport.ai) gives agents a wallet with owner-set spend guardrails. Agents create scoped **spending sessions**—per-transaction and total caps, asset and merchant allowlists, TTL, passkey approval—then pay for MPP-enabled services on demand. The wallet holds USDC across Base, Tempo, and Solana and settles Tempo MPP charges natively. Paste this into your agent: ``` Run: curl -fsSL https://agentpassport.ai/install.sh | bash Then use the kite-passport skill to log in and pay for MPP services. ``` :::steps ### Install the CLI ```bash [terminal] $ curl -fsSL https://agentpassport.ai/install.sh | bash ``` ### Log in ```bash [terminal] $ kpass login init --email ``` ### Register your agent ```bash [terminal] $ kpass agent:register --type claude ``` ### Create a spending session (owner approves via passkey) ```bash [terminal] $ kpass agent:session create \ --max-amount-per-tx 0.50 --max-total-amount 5.00 --ttl 1h --assets USDC ``` ### Make a paid request ```bash [terminal] $ kpass agent:session execute \ --url https://fal.mpp.tempo.xyz/fal-ai/flux/schnell \ --body '{"prompt": "a sunset over the ocean"}' ``` ::: **Supported methods:** tempo.charge tempo.session **Key features:** * **Owner-set guardrails**—scoped spending sessions enforce per-tx + total caps, asset/merchant allowlists, and TTL; every session approved by passkey * **Multi-chain balance**—one USDC balance across Base, Tempo, and Solana; Tempo MPP charges settle natively on Tempo, and the wallet also handles x402 services on Base * **Service discovery**—`ksearch services list` surfaces MPP-enabled endpoints with pricing and payment method ## `mppx` The [`mppx`](/sdk/typescript/cli) CLI is a lightweight MPP client bundled with the `mppx` package. It handles `402` responses automatically using a local keychain account—ideal for development, testing, and debugging. ::::steps ### Install :::code-group ```bash [npm] $ npm install -g mppx ``` ```bash [pnpm] $ pnpm add -g mppx ``` ```bash [bun] $ bun add -g mppx ``` ::: ### Create an account ```bash [terminal] $ mppx account create ``` ### Make a paid request ```bash [terminal] $ mppx https://mpp.dev/api/ping/paid ``` :::: **Supported methods:** tempo.charge tempo.session stripe.charge solana.charge **Key features:** * **Zero config**—create an account and start making paid requests immediately * **All payment methods**—supports every payment method implemented in the `mppx` SDK * **Local keychain**—private keys stored in the OS keychain, configurable via `MPPX_PRIVATE_KEY` env var * **Development-first**—designed for testing and debugging MPP integrations ## Next steps