> ## Documentation Index
> Fetch the complete documentation index at: https://crossmint-devin-1787949784-wallet-docs-two-concept-model.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# How Agents Pay

> Why agents need cards and stablecoin wallets, how allowances keep them safe, and how one Checkout API buys from any merchant

Agents operate across two distinct economies:

* **The traditional web runs on cards**. Amazon, Shopify stores, SaaS checkouts, and most traditional merchants rely on card payments. Users expect familiar properties like card rewards, refunds, and chargebacks.

* **The agentic web runs on stablecoins**. x402 and MPP-gated APIs, micropayments, and machine-to-machine settlement require stablecoins. Cards do not work here since fees, chargebacks, and merchant account constraints make small or programmatic payments impractical. Crossmint provides the stablecoin wallets, [x402](/agents/payment-flows/x402) and [MPP](/agents/payment-flows/mpp) protocols, and the [onramps](/agents/payment-methods/stablecoin-wallets/onramp-add-funds) to fund them.

Most agents need both, so **Crossmint provides cards and stablecoin wallets as first-class primitives.** Making an agent pay well comes down to two things: giving it **spending power under rules your users control**, and **routing each payment to the right destination**.

## Spending Power and Rules

You cannot give an agent unrestricted access to money:

* Credentials can be leaked
* Agents can overspend or behave unexpectedly

An agent with unlimited access is a liability. The goal is not just "agents can pay", it is "agents can pay securely without exposing sensitive data." Each instrument enforces this differently:

* **Cards.** The user's real card is stored in a PCI-compliant vault. An order intent gives the agent a fixed allowance with an amount, description, and expiration, enforced through Visa Intelligent Commerce or Mastercard Agent Pay. The agent never sees the real card number.

  The order intent tracks the total, reserved, spent, and available amounts. It stops working when cancelled, expired, or fully spent. See [Create an Agent Card](/agents/payment-methods/cards/create-agent-card) for details.

* **Stablecoin wallets.** The user owns a non-custodial wallet and grants the agent scoped permissions (spend limit, counterparties, time window), enforced onchain. Developers and agents never take custody of funds.

Every delegation is explicit, scoped, and revocable, so the user stays in control. Crossmint provides the UI components and signing flows; you wire them into your product.

<Tabs>
  <Tab title="Cards">
    <Steps>
      <Step title="User saves a card">
        Via a Crossmint-hosted secure iframe.
      </Step>

      <Step title="The app registers the card">
        Registration reports the card's supported rails. It grants no spending permission and requires no verification.
      </Step>

      <Step title="The app creates an order intent">
        The order intent defines the allowance amount, description, expiration, and optionally the merchant. Set the merchant here when you already know it; otherwise, supply it when minting each credential. Each rail reports whether it is active or requires verification.
      </Step>

      <Step title="The user verifies the allowance">
        The `OrderIntentVerification` component runs the Visa or Mastercard ceremony for a pending rail. A returning Visa user authenticates with the passkey already bound to the device.
      </Step>

      <Step title="Agent pays using a secure card number">
        The app mints a credential for a specific amount from an active rail. If the order intent is not already scoped to a merchant, the credential request supplies one. The agent uses the secure one-time card number in checkout or APIs.
      </Step>
    </Steps>
  </Tab>

  <Tab title="Stablecoin wallets">
    <Steps>
      <Step title="User creates and funds a non-custodial wallet">
        The user creates a non-custodial wallet via the Crossmint SDK and tops it up with USDC so the agent can pay. The recommended approach is the [Crossmint onramp](/agents/payment-methods/stablecoin-wallets/onramp-add-funds); direct USDC transfers work too. The user retains ownership so Crossmint and the developer never take custody.
      </Step>

      <Step title="User delegates scoped access to the agent">
        The agent gets its own key and is added as a **signer** on the user's wallet, bound to a permission set the user signs off on:

        * **Spend cap** — max amount the agent can move
        * **Allowed counterparties** — addresses or protocols the agent can interact with
        * **Time window** — when the delegation is valid

        Permissions are enforced onchain. The user can revoke at any time.
      </Step>

      <Step title="Agent transacts autonomously within scope">
        The agent signs and submits transactions with its own key — no user prompt per action. Anything outside the delegated scope is rejected at the wallet level.
      </Step>
    </Steps>
  </Tab>
</Tabs>

## Where Agents Spend

Once an agent has funded, rule-bound spending power, a payment still has to reach its destination. The right rail depends on *where* it is paying.

### Machine-Native Payments

To pay APIs and other agents, the agent settles in stablecoins directly:

| Flow                               | How it works                                                                      | Best for                         |
| ---------------------------------- | --------------------------------------------------------------------------------- | -------------------------------- |
| [x402](/agents/payment-flows/x402) | Agent calls an endpoint, gets `402 Payment Required`, pays in stablecoin, retries | Pay-per-call APIs, micropayments |
| [MPP](/agents/payment-flows/mpp)   | Agent-to-agent and service-to-service payments over a payment protocol            | Programmatic machine economies   |

### Merchant Checkout

Buying from a real merchant is the hard part. Today an agent has three options, and each falls short:

* **Buy through the merchant's API — if one exists.** Most merchants have no way to purchase programmatically at all.
* **Use an emerging agentic commerce protocol (UCP, ACP, …).** These help where a merchant has adopted one, but they typically hand back a checkout link rather than completing the purchase — and most merchants have not adopted any of them yet.
* **Drive a browser yourself.** This works anywhere, but it is slow and expensive: with today's frontier models a single checkout can burn several dollars in tokens, and a hand-rolled agent is not optimized for it.

**[Agent Checkouts](/agents/agent-checkouts-quickstart) unifies all three behind one API — and makes it cheap.** Hand it a product and a spending cap, and it:

* **Picks the right rail per merchant** — an agentic commerce protocol where one exists, and an **optimized browser session** as the universal fallback everywhere else. Crossmint runs and tunes that session, so you are not paying frontier-model prices to drive a browser on every purchase.
* **Completes the payment, not just the cart** — end to end, with any method the merchant accepts: a Crossmint Agent Card, another agent-card provider (Ramp, Link, …), a card already on file from a logged-in account, or a local method like Shop Pay, bank transfer, or Bizum.
* **Stays within your spending rules** — you set a hard cap and the checkout never spends above it.

The result: your agent can buy anything, anywhere — without wiring up a separate integration per merchant, or burning dollars in tokens per checkout.

## Choose Your Path

<CardGroup cols={3}>
  <Card title="Cards quickstart" icon="credit-card" href="/agents/cards-quickstart">
    Build an agent paying with agent cards.
  </Card>

  <Card title="Wallets quickstart" icon="wallet" href="/agents/stablecoin-wallet-quickstart">
    Build an agent paying with stablecoins.
  </Card>

  <Card title="Checkouts quickstart" icon="browser" href="/agents/agent-checkouts-quickstart">
    Buy from any merchant with a single API.
  </Card>
</CardGroup>