Give Your Agents Power to Purchase: Agentcard.sh Go-To Guide

I was sipping morning filter coffee and scrolling Product Hunt when agentcard.sh showed up. One look and I got flashbacks to a headache I fought last year.

I was building a procurement agent in Node.js. Find office supplies. Fill the cart. Check out alone. The model was great at shopping. The payment screen killed the whole flow.

That is the real problem: agents got good at everything before pay. Paying still needed a human — or a dangerous hack like pasting your real debit card into the agent.

Agentcard is built for that gap — give your agents power to purchase, without handing over the whole bank account. This is the practical guide I wish I had on day one.

The problem agentcard.sh solves

Picture the happy path people sell in demos:

1. User: “Buy printer paper under $50.”
2. Agent searches, compares, fills the cart.
3. Agent… stops. Or asks you to paste a card. Or loops and double-charges.

Step 3 is where most “autonomous” agents die.

What you actually need: a payment method the agent can mint in code, with a hard spend cap, that dies after one charge, so a retry cannot bill you twice.

That is what agentcard.sh ships: virtual Visa cards for AI agents, funded from a wallet, created over MCP / CLI / API.

In one line: Agentcard turns “pay” into a tool call, not a bank-account handoff.

What is Agentcard (and what is it not)?

From their own product framing:

• Network: Visa — virtual, card-not-present (online) only
• Lifecycle: single-use — card closes after the first approved charge; leftover money returns to the wallet
• Funding: you (or your user) fund a wallet; each card’s limit is taken from that balance
• Control: budgets, approvals, KYC, fraud checks

Two products on one platform (docs intro):

When should you use Agentcard?

• Buy something online (API credits, domains, SaaS, data, licenses, delivery)
• Need a hard-capped virtual card for one task
• A human asked the agent to purchase something and it needs real credentials
• You are building a product whose agents purchase for end users (Companies)

When should you not use it?

• In-store / physical POS
• Recurring auto-renew billing (cards are single-use)
• Sending money to a person
• Merchants that force interactive 3DS / SMS OTP

How does the money flow work?

You fund wallet (Apple Pay / Google Pay)
        ↓
Agent creates card for $X  →  $X reserved from wallet
        ↓
Agent pays online with PAN / CVV / expiry
        ↓
First charge succeeds  →  card closes
        ↓
Unused amount returns to wallet

One-time gates on first live use (agent will ask you):

1. Phone verify before first wallet fund (stays fresh ~60 days)
2. KYC (ID + short face scan) before first live card

Treat PAN/CVV like passwords — use them to fill checkout, never write them to logs, chats, or analytics.

Units gotcha (this bites everyone):

• Personal CLI uses dollars: --amount 25 = $25
• MCP tools use cents: amount_cents: 2500 = $25

If you copy 25 into MCP, you get a $0.25 card. Always convert.

Path A — Personal: give your agent a card

Best if you use Cursor, Claude Code, or Claude Desktop and want your own agent to finish checkout.

1. Sign up + fund

npm install -g agent-cards
agent-cards signup
agent-cards wallet fund --amount 50   # DOLLARS — opens Apple Pay / Google Pay
agent-cards wallet                    # check balance

2. Connect MCP (same URL everywhere)

Endpoint: https://mcp.agentcard.sh/mcp
Auth: OAuth — no API key in config. Sandbox vs live comes from the credential, not the URL.

Cursor / Windsurf (.cursor/mcp.json):

{
  "mcpServers": {
    "agent-cards": {
      "url": "https://mcp.agentcard.sh/mcp"
    }
  }
}

Claude Desktop — same block in claude_desktop_config.json.

Claude Code:

agent-cards setup-mcp
# or
claude mcp add --transport http agent-cards https://mcp.agentcard.sh/mcp

Restart the agent. First tool call opens the browser sign-in.

3. Typical agent flow (copy this into your mental model)

1. Agent calls get_instructions
2. fund_wallet if balance is low (you pay in the browser)
3. create_card with amount_cents (e.g. 5000 = $50)
4. Finish KYC if asked
5. get_card_details only when filling a form (may need approve_request)
6. Pay — or use conversational buy / pay_checkout
7. Card auto-closes after first charge

Useful tools: create_card, get_card_details, check_balance, close_card, buy, approve_request, list_cards.

Try this prompt after MCP is connected:

Call get_instructions, then create a $20 Agentcard (2000 cents).
Use buy to order something under that limit.
Confirm the total with me before paying. Never log the full card number.

CLI without an agent:

agent-cards cards create --amount 20
agent-cards cards list
agent-cards cards details <card_id>
agent-cards cards close <card_id>

Path B — Companies: card issuing for agent-first startups

This is the agentcard.sh product for platforms. Your users keep their own Agentcard. Your app never needs to store card numbers.

Problem it solves for startups: “Our agent can shop for the user, but we cannot take their real card into our servers — and we cannot stop at ‘please pay yourself’.”

Fastest path: the wizard (~5–20 min)

npx agent-cards-admin wizard --agent --yes --email you@company.com --app-url http://localhost:3000

What you get:

1. Sandbox only (no real money)
2. Org + OAuth client; secrets written to .env / .env.local (not shown to the AI)
3. Idiomatic code edits for Connect with Agentcard
4. A real sandbox card as proof
5. Dashboard link like app.agentcard.sh/org/…

Edits stay uncommitted — review, then commit. Re-runs are safe.

Interactive:

npm install -g agent-cards-admin
cd /path/to/your/app
agent-cards-admin wizard

How does your product call Agentcard?

Every request uses the user’s access token:

curl -X POST https://mcp.agentcard.sh/mcp \
  -H "Authorization: Bearer <user_access_token>" \
  -H "Accept: application/json, text/event-stream"

Rules that keep you out of trouble:

• Register tools from tools/list dynamically — do not hardcode forever
• approval_required means nothing moved yet — resolve with approve_request after the human says yes
• Your token only sees cards your app created for that user
• If KYC / funding is needed, tell the user; they finish it in their Agentcard account, then retry

Going live: subscribe → agent-cards-admin env production → create a separate production OAuth client. Keep sandbox for day-to-day.

Full Companies docs: docs.agentcard.sh/companies.

How do you create a card from code (when you are not on MCP)?

Prefer MCP + OAuth for agents. If you still need a raw create call (as on the marketing site):

curl -X POST https://api.agentcard.sh/api/v1/cards \
  -H "Authorization: Bearer $AGENTCARD_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"amountCents": 5000}'

Slim TypeScript sketch:

async function provisionAgentCard(amountCents: number) {
  const response = await fetch("https://api.agentcard.sh/api/v1/cards", {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.AGENTCARD_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({ amountCents }),
  });

  if (!response.ok) {
    throw new Error(`Card create failed: ${response.status}`);
  }

  // Keep PAN/CVV in memory for checkout only — never log them.
  return response.json();
}

await provisionAgentCard(4500); // $45.00

Why is this design safer than “just give the agent a card”?

Still start small: $10–$20 cards, approvals on, secrets out of logs.

Useful things to do with Agentcard this week

1. Delivery under a hard budget

Get me sushi for less than $40 from my usual place.
Use Agentcard buy. Confirm total before checkout.

2. Finish the procurement agent (the one that used to break)

Order 5 packs of A4 paper.
Create a one-time Agentcard capped at cart total + 10%.
Ask me to approve if it crosses my limit.

3. Weekly groceries

Restock milk, eggs, bread. Budget $60.
Use my default address. Ask before paying.

4. Messaging product (“text me toilet paper”)

Companies examples (Twilio, chat SDKs, iMessage bridges): user texts a buy request → agent collects details → Agentcard pays → confirmation stays in the same chat. That is the product story agentcard.sh is selling to agent-first startups.

5. Browser agent without wasting tokens on forms

Create a capped card → Chrome extension / fill_card / pay_checkout → agent skips fighting checkout DOM.

6. Solo founder SaaS checkout

Buy the cheapest monthly plan that unlocks API access.
Cap the card at $30. Close after success.

Plans (Personal)

Check live limits with agent-cards plan. Companies billing is separate — see agentcard.sh or schedule a call.

Checklist

If you are a person with an agent

• agent-cards signup
• Fund wallet
• Connect https://mcp.agentcard.sh/mcp
• get_instructions → small card → one real buy
• Remember: MCP = cents, CLI = dollars

If you are building a product

• Run agent-cards-admin wizard in sandbox
• Review the uncommitted diff
• Prove a sandbox card
• Subscribe + separate production OAuth client before live money

Always

• Tiny limits first
• Never log PAN / CVV
• Read docs.agentcard.sh

Final thought

The agent economy was missing boring plumbing: a safe way to pay.

agentcard.sh does one job well — issue a capped virtual Visa your agent can use today, then throw the card away. Personal for your own agent. Companies for startups that need “Connect with Agentcard” inside the product.

I am dusting off that old procurement script this weekend. If you are shipping an agent-first app, start with the wizard. If you just want dinner ordered by Claude, connect MCP and try a $20 card first.

More links I keep open:

• Product: agentcard.sh
• Docs: docs.agentcard.sh
• Dashboard: app.agentcard.sh
• Launch page: Product Hunt — Agentcard