AI agents can browse the web, call APIs, and complete multi-step tasks autonomously. But the moment they need to buy something — API credits, a domain, a SaaS subscription — they're stuck. No payment method.
We built AgentCard to fix that. Create a prepaid virtual Visa, hand the details to your agent, and let it handle checkout. The card has a hard spending limit, so the worst case is losing the card balance. Not your credit line.
This guide covers setup, which agents work best for purchases, and what to watch out for.
Setup (works with every agent)
The AgentCard CLI is the same regardless of which agent you use. Three commands and you're ready.
1. Install the CLI
npm install -g agentcard
2. Sign up
agentcard signup --email you@example.com
Magic link in your inbox. Click it. One-time thing — your session is stored at ~/.agentcard/config.json.
3. Create a virtual card
agentcard create --amount 25
Stripe Checkout opens. Pay with a credit card or USDC. About 4 seconds later, you have a virtual Visa with a hard $25 limit.
4. Get card details
agentcard details <card-id>
Returns the 16-digit card number, CVV, expiry, and billing address. Everything an agent needs to complete a purchase.
Other useful commands
# Check remaining balance
agentcard balance <card-id>
# Refund unused balance
agentcard refund <card-id> --amount 10
Your agent can run this entire flow autonomously if it has terminal access. Or you can run the commands yourself and hand over the card details. Both work.
Agent compatibility
Not all agents make purchases the same way. The key difference is how they handle the "last mile" — actually entering card details at checkout. Some agents have browser access and can fill out visual checkout forms. Others work through APIs and scripts only.
| Agent | Terminal | Browser | MCP | Best checkout method | |---|---|---|---|---| | Claude Code | Yes | No | Yes | API / CLI | | Cursor | Yes | No | Yes | API / CLI | | Devin | Yes | Yes | No | Visual form-fill | | Cline | Yes | Yes | No | Visual form-fill | | Claude Cowork | Yes | Yes (screen) | No | Visual form-fill | | Replit Agent | Yes | Yes | No | Visual form-fill | | OpenClaw | Yes | Yes | No | Visual form-fill | | GitHub Copilot | Yes | No | No | API / CLI | | Windsurf | Yes | No | No | API / CLI | | Aider | Yes | No | No | API / CLI | | OpenAI Codex | Yes (sandbox) | No | No | API / CLI | | Custom agents | Varies | Varies | Varies | Depends on your setup |
Terminal = can run shell commands like agentcard create and agentcard details.
Browser = can navigate web pages and fill out checkout forms visually.
MCP = supports Model Context Protocol, so it can discover AgentCard commands automatically via our skill endpoint at agentcard.ai/skill.
Agents with browser access
These agents can handle any merchant — even ones that only offer a web checkout form. They create the card via CLI, then open a browser and fill in the payment details like a human would.
Devin
Devin gets its own sandbox with a shell, browser, and code editor. It runs the full loop: install the CLI, create a card, open a merchant's website, fill in the checkout form, and complete the purchase. Then it keeps going — buy a server, then configure it. Buy a domain, then set up DNS. The purchase is step one, not the whole task.
Devin's sandbox is persistent, so your AgentCard session carries over across interactions without re-authenticating.
Cline
Cline runs inside VS Code and has a browser-use integration that lets it navigate actual web pages. Terminal mode handles the AgentCard CLI commands; browser-use mode handles checkout forms. It reads form labels, fills in fields, and clicks through multi-step checkouts.
Enable browser-use in Cline's settings to get the full purchasing flow. Without it, Cline still works for API-based purchases through the terminal.
Claude Cowork
Anthropic's desktop agent uses the Computer Use API to interact with your screen. It literally sees the checkout page, finds the form fields, and fills them in. This makes it the most flexible agent for visual checkout — it handles custom forms, multi-step flows, CAPTCHAs, and account creation mid-checkout.
Since Cowork works on your visible desktop, you can watch every step in real time.
Replit Agent
Cloud-native with terminal and a built-in browser. No local setup required — everything runs in your Repl. The browser handles visual checkouts, and the persistent environment means your AgentCard session sticks around between tasks.
OpenClaw
Runs locally with browser automation through its skill system. You can create a dedicated AgentCard skill in your SOUL.md config so the agent knows the full workflow. OpenClaw's 13,700+ community skills on ClawHub make it particularly flexible for chaining purchases with other tasks.
Terminal-only agents
These agents can create cards and retrieve details, but they can't fill out web checkout forms. They work best with merchants that have billing APIs, CLIs, or URL-based checkout. That covers more services than you'd expect — most developer tools, cloud platforms, and API providers accept payment programmatically.
Claude Code
Our most popular integration. Claude Code runs shell commands in your terminal — agentcard create, agentcard details, straight through to the purchase API call. It also supports MCP, so you can point it at agentcard.ai/skill and it learns every AgentCard command on its own. Zero prompting required.
We built AgentCard using Claude Code, so this one's close to home.
Cursor
Cursor's agent mode runs terminal commands directly in VS Code. It also supports MCP, which means it discovers AgentCard tools natively. Switch to agent mode (Cmd+I), describe what you want to buy, and Cursor handles card creation through purchase completion.
GitHub Copilot
In agent mode, Copilot runs terminal commands and chains multi-step tasks. It writes API calls, fills in card details from CLI output, and executes the purchase. No browser access, so stick to merchants with programmatic billing.
Windsurf
Windsurf's Cascade mode executes shell commands from the chat panel. Terminal-first workflow — great for API purchases, domain registration via CLI, and cloud service credits. No browser automation, so web-only checkout forms need manual entry.
Aider
Pure terminal. No GUI, no browser. Aider excels at writing purchase scripts — it creates the card, grabs the details, and generates a ready-to-run script using the merchant's API. For services without APIs, Aider retrieves the card details and you handle checkout yourself.
OpenAI Codex
Cloud sandbox with full shell access. Codex writes integration code from scratch, which is useful for merchants without pre-built SDKs. One setup note: since Codex runs in the cloud, you need to authenticate locally first and pass your session token to the sandbox as an environment variable.
MCP integration
Agents that support MCP — currently Claude Code and Cursor — have an advantage. MCP lets agents discover tools in a standardized way, so they don't need to be taught how AgentCard works.
Point your MCP-compatible agent at our skill endpoint:
agentcard.ai/skill
It returns machine-readable instructions for every AgentCard command — actions, parameters, expected outputs. The agent reads it and figures out the workflow on its own.
We've watched Claude Code go from zero knowledge to completing a purchase in under a minute using just the skill endpoint. No prompting about how AgentCard works.
Security
Giving an AI agent a credit card sounds scary. We designed AgentCard specifically to make it not scary.
Hard spending limits
A $25 card maxes out at $25. Full stop. The card literally cannot be charged more, regardless of what the agent does. This isn't a soft limit or a setting — it's baked into the card at the issuer level.
One card per task
Create a fresh card for each purchase. A domain registration gets its own $15 card. API credits get their own $50 card. No credential reuse across tasks. If one card is compromised, the blast radius is that card's balance — nothing else.
Your real card stays hidden
Stripe handles the funding. The agent never sees your personal payment method. The virtual card credentials are the only thing exposed, and they're tied to a fixed, non-reloadable balance.
Right-size every card
Item costs $12? Make a $15 card. Don't load $100 "just in case." Tighter limits mean less exposure.
Verify after every purchase
Have your agent run agentcard balance <card-id> after each purchase to confirm the charge amount. Refund any unused balance with agentcard refund.
Agents with browser access: extra considerations
Browser-capable agents (Devin, Cline, Cowork, OpenClaw, Replit Agent) are more powerful but warrant more attention. Most of these agents show you their intended actions before executing — use that approval step. Watch what pages they navigate to and what forms they fill in.
Example workflows
These work with any agent that has terminal access. Agents with browser access can also handle merchants that only offer web checkout.
API credits
"Create a $50 AgentCard and use it to buy OpenAI API credits for my account."
The agent creates the card, retrieves details, and hits the billing API. Fixed balance means it physically cannot spend more than $50.
Domain registration
"Create a $15 AgentCard and register mycoolproject.dev on Namecheap."
Terminal-only agents use the registrar's API. Browser agents navigate to the site and complete checkout visually.
SaaS subscriptions
"Create a $20 AgentCard and subscribe to the Postmark starter plan."
Nice side effect: since the card has a fixed balance, renewal charges get declined automatically. No surprise recurring bills.
Cloud infrastructure
"Create a $100 AgentCard and set up a Vercel Pro plan for our team project."
Works through billing APIs or browser checkout, depending on the agent.
Quick start
# Install the CLI
npm install -g agentcard
# Sign up (click the magic link in your email)
agentcard signup --email you@example.com
# Create a $25 virtual card (opens Stripe Checkout)
agentcard create --amount 25
# Get card details (number, CVV, expiry)
agentcard details <card-id>
Tell your agent what to buy. It takes it from there.
Cards work at any US-based merchant that accepts Visa. We launched in March 2026 and have processed thousands of agent purchases. Create a card, hand it to your agent, let it work.