AgentCard pricing, plans and limits

AgentCard lets AI agents create their own single-use virtual Visa cards over MCP. A human approves each card, the agent pays with it, and it self-destructs after one use. Identity verification is now required for every card. Built by Agentcard Corporation, backed by Y Combinator, compatible with Claude Code, Cursor, and any MCP agent.

AgentCard is an MCP server from Agentcard Corporation that lets AI agents issue single-use prepaid virtual Visa cards. Agents call create_card, receive full card credentials, and pay anywhere Visa is accepted, with mandatory identity verification required since April 2026. It works with Claude Code, Cursor, Cline, Windsurf, and 40+ MCP clients.

Maker: Agentcard Corporation · Protocol: MCP · Auth: token

Compatible agents: Claude Code, Claude Desktop, Cursor, Cline, Windsurf, OpenClaw, ChatGPT (via app store), Any MCP HTTP client

Required runtime: Node.js >= 18 (for agent-cards CLI), Stripe-connected payment method (for card funding)

About AgentCard

AgentCard is a Model Context Protocol (MCP) server built by Agentcard Corporation, a Delaware company backed by Y Combinator, that lets AI agents issue and spend prepaid virtual Visa cards without ever seeing a real payment credential. Co-founded by CEO Karen Serfaty and CTO Felipe Abello, the product launched publicly in early 2026 and demoed live at MCP Night 4 in May 2026, where an agent paid for an OpenAI subscription entirely from the terminal.

The service runs as a hosted HTTP MCP server, with card credentials encrypted at rest using AES-256-GCM and only decrypted on an explicit request. A human sign-off gate sits in front of every card mint and every charge, keeping an agent's spending proposals separate from execution. Since April 2026, Agentcard has also required a one-time identity check on every account, a compliance step it added well ahead of most fintech competitors serving individual developers.

Any MCP-compatible agent can connect, including Claude Code, Claude Desktop, Cursor, Cline, Windsurf, and OpenClaw, and the company added ChatGPT app-store distribution in mid-2026. Setup is a single JSON config block plus the agent-cards npm package; calling get_instructions loads the current usage rules straight into the agent's context.

Personal pricing now spans three tiers that trade a higher monthly fee for a higher per-card ceiling and more cards per month, alongside a flat-rate plan built for platforms issuing cards to many end-users at once. Full current figures for every tier are in the cost FAQ below; Agentcard published pricing for its platform tier for the first time in 2026, having previously quoted it case by case.

Weekly shipping continued through August 2026: a Slack integration lets a team create a card straight from a /card command, a Chrome extension called AgentCard Pay autofills checkout pages, and structured error codes plus webhook notifications make failures easier to handle programmatically. The team says the roadmap points toward fully autonomous multi-item checkout, merchant linking, and delivery-address handling, all still gated behind the same human-approval step.

Key Features

• MCP-native card issuance: Agents call create_card with an amount in cents and receive a live Visa card number, CVV, and expiry within seconds, with no custom HTTP integration code required.
• Human approval checkpoint: Every card creation and every charge requires explicit human sign-off before funds move, so agents can propose spending but cannot execute it unilaterally.
• AES-256-GCM credential encryption: Full card credentials (PAN, CVV, expiry) never leave encrypted storage until a specific tool call requests them, reducing exposure in logs or memory.
• Identity verification via Stripe Identity: Since April 2026, every card requires a one-time government-ID check through Stripe Identity before it can be created, a KYC step enforced across every pricing tier.
• 20+ specialized MCP tools: The server exposes tools for card lifecycle management, balance checks, transaction history, payment method management, plan upgrades, checkout autofill, and natural-language purchasing via the buy tool.
• Visa acceptance worldwide: Each issued card is a prepaid Visa accepted at any online merchant worldwide that takes Visa, with no geographic or merchant category restrictions beyond the card's fixed spend cap.
• Three-tier Personal pricing plus a flat-rate Companies plan: Personal users choose from Free, Basic, and Pro tiers with rising card limits, while platforms scale on a flat monthly Companies plan with unlimited card issuance and usage-based interchange.

Use Cases

• Automated SaaS subscription renewal: An agent monitors a subscription expiry date, calls create_card with the exact renewal price, then fills the card at the merchant checkout so the developer never shares their real payment credentials.
• API credit replenishment: A coding agent tracks its own remaining API credits, issues a $20 card when the balance drops below a threshold, and tops up its provider account without any human touchpoint beyond the initial approval.
• Natural-language e-commerce checkout: A shopping agent calls the buy MCP tool with a plain-English description such as 'buy a 6-month gym membership', browses linked merchants, builds a cart, and completes checkout with a freshly issued card scoped to the exact cart total.
• One-off software license procurement: A developer agent identifies a missing dependency or tool, purchases a $10 license, and installs it in one terminal session without the developer ever entering payment details manually.

Install

npx agent-cards setup-mcp

Requirements

• Node.js 18 or later installed (npm comes with Node)
• Run agent-cards login to authenticate via magic-link email and generate your AGENT_CARDS_JWT
• Add a payment method via the setup_payment_method MCP tool or Stripe Checkout before creating any cards
• Add the MCP server to your agent config: URL https://mcp.agentcard.sh/mcp, transport HTTP, Authorization: Bearer <AGENT_CARDS_JWT>

Actions

Create Card

Issues a new single-use prepaid virtual Visa card with a fixed spend limit, holding the amount on your saved payment method.

{
  "name": "create_card",
  "arguments": {
    "amount_cents": 2500
  }
}

• amount_cents (number) — required: The card's spend limit in US cents. For example, 2500 = $25.00. Free plan maximum is 5000 (=$50); Basic plan maximum is 50000 (=$500).

List Cards

Returns all virtual cards on the account with their IDs, last four digits, expiry dates, balances, and statuses.

{
  "name": "list_cards",
  "arguments": {}
}

Check Balance

Retrieves the current balance of a specific card without exposing the full card credentials.

{
  "name": "check_balance",
  "arguments": {
    "card_id": "card_abc123"
  }
}

• card_id (string) — required: The unique ID of the card to check, as returned by create_card or list_cards.

Get Card Details

Decrypts and returns the full card number (PAN), CVV, and expiry date needed to complete a payment. May require human approval before returning credentials.

{
  "name": "get_card_details",
  "arguments": {
    "card_id": "card_abc123"
  }
}

• card_id (string) — required: The unique ID of the card whose credentials to retrieve.

Close Card

Permanently closes a virtual card. This action is irreversible and any remaining balance is released back to the payment method hold.

{
  "name": "close_card",
  "arguments": {
    "card_id": "card_abc123"
  }
}

• card_id (string) — required: The unique ID of the card to permanently close.

List Transactions

Retrieves the full transaction history for a specific card, showing merchant name, amount, status, and timestamps.

{
  "name": "list_transactions",
  "arguments": {
    "card_id": "card_abc123"
  }
}

• card_id (string) — required: The unique ID of the card whose transactions to retrieve.

Setup Payment Method

Opens a Stripe Checkout session to save a new payment method (credit or debit card) to the account, which is used to fund future virtual cards.

{
  "name": "setup_payment_method",
  "arguments": {}
}

List Payment Methods

Returns all saved payment methods on the account with their brand, last four digits, expiry, and which one is set as the default.

{
  "name": "list_payment_methods",
  "arguments": {}
}

Get Plan

Displays the current plan (Free or Basic), the per-card spending cap, monthly card usage count, and available upgrade options.

{
  "name": "get_plan",
  "arguments": {}
}

Buy

Conversational purchase tool that accepts a natural-language description of what to buy and handles merchant lookup, cart building, and checkout end-to-end.

{
  "name": "buy",
  "arguments": {
    "description": "Buy a 1-month ChatGPT Plus subscription for $20"
  }
}

• description (string) — required: Plain-English description of the purchase to complete, including the item, quantity, and optionally the target merchant.

Pay Checkout

Creates a new virtual card and immediately fills it into an active browser checkout form in a single atomic operation, minimising the window in which credentials are exposed.

{
  "name": "pay_checkout",
  "arguments": {
    "amount_cents": 4999
  }
}

• amount_cents (number) — required: The exact amount in cents to load onto the card and charge at the checkout form currently open in the browser.

Get Instructions

Returns the current usage guide for AgentCard MCP tools. Call this at the start of any agent session to ensure the agent uses the most up-to-date workflow.

{
  "name": "get_instructions",
  "arguments": {}
}

Get Funding Status

Polls the status of a card creation after the Stripe Checkout payment step, confirming when the card is funded and ready to use.

{
  "name": "get_funding_status",
  "arguments": {
    "card_id": "card_abc123"
  }
}

• card_id (string) — required: The card ID returned by create_card, used to poll whether the Stripe payment has settled and the card is active.

x402 Fetch

Performs an HTTP request and automatically handles HTTP 402 Payment Required responses by issuing a virtual card and paying the requested micropayment amount without human intervention.

{
  "name": "x402_fetch",
  "arguments": {
    "url": "https://api.example.com/premium-endpoint",
    "method": "GET"
  }
}

• url (string) — required: The URL to fetch. If the server returns HTTP 402, AgentCard automatically pays and retries.
• method (string): HTTP method: GET, POST, PUT, DELETE. Defaults to GET.
• body (string): Request body for POST/PUT requests, as a JSON string.
• headers (object): Additional HTTP headers to include in the request.

How to Invoke

Exposed as 20+ MCP tools (create_card, list_cards, check_balance, get_card_details, buy, and more) called by any MCP-compatible agent after registering the HTTP server at https://mcp.agentcard.sh/mcp with JWT Bearer auth.

Pricing

Personal: Free ($0/mo, 5 cards/mo, up to $50 per card, no card required to start), Basic ($15/mo, 15 cards/mo, up to $500 per card), Pro ($100/mo, 50 cards/mo, up to $1,000 per card). Loading money into the balance is free and withdrawals to a bank account carry no lock-in. Stripe's normal processing fee is charged separately on every funding transaction. Companies: $5,000/mo flat, unlimited cards, spend limits set per agent from the dashboard, a 1% cut of settled-purchase interchange, plus a platform-set markup, with a 30-day money-back guarantee.

Strengths

• Zero integration code required: any MCP-compatible agent (Claude Code, Cursor, Cline, Windsurf) can start issuing cards with one config block and npm install -g agent-cards.
• Spend-cap safety by design: cards are backed by Stripe payment-method holds, so the maximum possible loss from any runaway agent is the card's loaded amount with zero overdraft risk.
• Human-in-the-loop gates: approval checkpoints before each card mint mean developers retain full financial control even as agents operate autonomously across multi-step workflows.
• One of the few virtual card products built natively on MCP, which means agents use standardized tool-calling instead of bespoke REST wrappers.

Weaknesses

• Every paid tier is now a recurring monthly subscription rather than a single upgrade fee, and the Free tier also caps the number of cards issued per month, not just their size.
• Human approval adds workflow friction: the required approval step before each card creation breaks fully autonomous pipelines and cannot be pre-authorized for specific merchants or amount ranges.
• Beta status persists into September 2026: the API surface keeps changing (identity verification added April 2026, a new Pro tier and published Companies pricing added mid-2026), so integrations should expect breaking changes.
• Self-hosted Docker setup requires managing JWT auth and the AGENT_CARDS_JWT environment variable yourself, adding operational overhead compared to the one-command hosted path.

View the official AgentCard skill page