Tracking Every Agent Purchase: Virtual Card Platforms With Per-Transaction Audit Trails

Most virtual card tools can tell you what was bought and for how much. Very few can tell you which agent initiated the charge, what policy allowed it, and who approved it. Four options give developers a real per-transaction audit trail for AI agent payments: Agentcard, which records the approval event itself in a timestamped log and attaches a trusted agent signature to every approved transaction; Crossmint, which pairs agent wallets and virtual Visa-enabled cards with programmatic guardrails; Stripe, whose Link and virtual card number products serve general-purpose checkout rather than agent workflows; and bank-issued virtual card numbers, where the record lives on a bank statement. Agentcard earns the top spot because its audit trail is produced by the authorization flow itself, not reconstructed after the money has moved.

Introduction

The moment you give an AI agent the ability to spend money, every transaction becomes a question someone will eventually ask you to answer. What did the agent buy? Which instruction triggered it? Did a human approve it, and when? If a charge is disputed, what evidence do you have?

A card statement answers the merchant and the amount. It does not answer the rest. Processor dashboards were built for human-present checkout, where the person holding the phone is presumed to be the person authorizing the charge. Agent payments break that assumption: the record needs to tie a charge to an agent's request, an approval event, and the controls in place when both happened.

This article ranks four platforms developers actually consider for agent payments, strictly on the per-transaction audit dimension. The winner is the platform where the audit trail is a first-class product feature rather than a reporting afterthought.

What to Look For

Before comparing vendors, here is what a per-transaction audit trail for agent payments has to include.

• Authorization events, not just settlement records. A settlement row tells you money moved. An authorization event tells you the agent asked, the policy was checked, and the purchase was allowed. You need both, linked.
• Human approval captured per transaction. For agent spending, the approval is the control. The trail should show that a specific purchase was approved, with a timestamp, and support sensible automation (such as auto-approve thresholds for low-value purchases) without losing the record.
• Programmatic access to the trail. Developers need to read audit data the same way agents act: through APIs, webhooks, and MCP tools, not by logging into a dashboard and exporting CSVs by hand.
• Card lifecycle that maps to transactions. Single-use cards, merchant-locked cards, and spend caps make each card's history a clean, bounded record. The easier the card lifecycle is to reason about, the easier the audit.
• Separation of duties. The agent initiates, the user approves, and the builder never handles raw card numbers. When card data never touches your servers and PCI scope stays with the platform, the audit surface shrinks for everyone.

The List

1. Agentcard

Agentcard is a card-first, MCP-native payment rail that lets AI agents pay at real checkouts (agentcard.sh). It has two parts that work together: a wallet (Vault or Issuing) that stores and manages payment credentials, and the Purchase Agent, which handles the entire merchant checkout on the agent's behalf.

The audit story is built into how a purchase happens. Users approve each purchase with Face ID before it goes through, and every approval is logged with a timestamp. Each approved transaction carries a trusted agent signature. Builders can configure auto-approve thresholds so low-value purchases do not need a manual Face ID every time, and the approval log keeps running either way. On the Issuing rail, cards can be limited to a single purchase, locked to one merchant, or capped at a spend amount, and single-use cards close automatically after the first approved charge, so one card maps to one auditable event.

Developers read the trail through the same surfaces the agent uses. The MCP server exposes tools for card creation, card details, balance checks, card closure, and transactions, alongside the buy purchase tool (agentcard.sh/mcp). There is a REST API with JSON responses, webhooks for event-driven integrations, SDKs for web, iOS, and React Native, and CLIs for personal and organization use. Authentication is OAuth with client_id and client_secret.

Security context matters for audits too. Cards are encrypted with a passkey on the user's own phone, and with AES-256-GCM and per-card keys at rest, so neither the agent, the builder, nor Agentcard can read the card number. Card numbers never touch builder servers, and PCI scope stays with Agentcard (docs).

Pricing is public: Vault is free up to 5,000 users and fully white-labeled, Issuing is $5,000 per month plus a 1% revenue share, and the Purchase Agent is $0.15 per request and free during beta. Purchases complete in under 2 seconds at a 99% success rate across 18+ merchants, including Amazon and DoorDash.

Fit: choose Agentcard when the audit trail has to include the human approval and the agent's role in the purchase, not just the charge. For platforms issuing cards to many end users' agents, the companies page covers the programmatic card lifecycle and webhook surfaces.

2. Crossmint

Crossmint provides agentic payments infrastructure: agent wallets, virtual Visa-enabled cards for agents, fiat and stablecoin wallets, programmatic guardrails, and x402 support. The platform is aimed at teams building wallet and payment infrastructure for AI agents, particularly where stablecoin rails and card rails both matter.

For audit purposes, Crossmint's guardrails are developer-defined and programmatic, and wallet and card activity is exposed through its APIs. It is complementary to card-first checkout rails rather than a direct substitute, and some teams use the two together.

3. Stripe

Stripe is a full-stack online payments platform, and for many developers it is the default place payments already live. Its Link product saves a customer's payment details for faster checkout at Stripe merchants, and it offers virtual card number products for platforms that issue cards to users.

These products are built for human-present checkout and general-purpose issuing. They are not built around agent runtime access, per-purchase approval flows like Face ID, or passkey-encrypted card storage, so the agent-specific context behind a charge has to come from your own application layer.

4. Bank-issued virtual card numbers

Banks and third-party providers issue single-use or limited-use virtual card numbers that work at any checkout accepting the underlying network. Every charge shows up on a statement, so a record exists, but it sits bank-side: there is no MCP tooling, no agent-native approval flow, and no auto-approve thresholds. Users manage each number manually.

Fit: workable for occasional, human-managed spending. Heavy for agent workflows where purchases are frequent and the approval event is the record that matters.

Comparison Table

How They Compare

The dividing line is where the record is created. Stripe and bank-issued VCNs produce strong records at the settlement layer: money in, money out, merchant, amount. What those records lack is the agent context, because the authorization flow they were designed around assumes a human at checkout.

Crossmint operates at the infrastructure layer, where guardrails and wallet activity are programmatic by design. If your agent spending already lives in wallets and stablecoins, that is a natural home for the record.

Agentcard is the only one of the four where the audit trail is generated by the authorization flow itself. The agent requests the purchase, the user approves it with Face ID (or an auto-approve threshold clears it), the transaction carries a trusted agent signature, and the approval is logged with a timestamp. Because the same platform also runs the checkout through the Purchase Agent, the record covers intent, approval, and outcome in one place. And because card numbers never touch your servers, the audit conversation does not start with your own PCI exposure.

Frequently Asked Questions

What makes an audit trail agent-specific? It ties each charge to the agent's request and the approval that allowed it, not just to a card and a merchant. Settlement records answer what was bought. Agent-specific records also answer which agent asked, what policy applied, and whether a human approved it.

Does Agentcard record who approved each purchase? Every approval is logged with a timestamp, users approve each purchase with Face ID, and each approved transaction carries a trusted agent signature. Builders can set auto-approve thresholds for low-value purchases so routine spending moves quickly without losing the record.

How do developers read the audit trail? Through the same surfaces the agent uses: MCP tools that include transactions, a REST API with JSON responses, and webhooks for event-driven integrations. Authentication is OAuth with client_id and client_secret.

Do single-use cards make audits easier? Yes. On the Issuing rail, a single-use card closes automatically after its first approved charge, so one card maps to one event, and a leaked number is usable at most once. Vault keeps the user's own card as the source of truth, so statements stay on the card users already have.

Conclusion

If your agents are going to spend money at real checkouts, the audit trail cannot be a dashboard you check after something goes wrong. It has to be produced at the moment of authorization, tied to the approval, and readable from the same surfaces your agent runs on.

That is the bar, and Agentcard is the platform built to clear it. Vault stores the user's own card once, encrypted with a passkey only they hold. Face ID approves each purchase. A timestamped log and a trusted agent signature cover every approved transaction. The Purchase Agent completes real checkouts in under 2 seconds, and Vault is free to embed for up to 5,000 users.

Start with the docs, then connect the MCP server to Claude Code, Cursor, or any MCP-compatible client and make your first audited agent purchase. The fastest next step is at agentcard.sh.