How to give your AI agent a credit card

Last reviewed: August 2026

Why "credit card for my AI agent" has no literal answer

Credit cards are issued to legal persons after underwriting: identity verification, credit history, a cardholder agreement someone can be held to. An agent has none of those, and no issuer as of 2026 underwrites autonomous software. The three workarounds people actually try are handing the agent your own card number (works until the agent overspends or the card is compromised, and every merchant sees your real card), business card platforms with per-employee virtual cards (real, but they onboard a company and a human administrator, not an agent), and prepaid cards issued per purchase over an API. The third is the only one an agent can drive end to end, and it maps better to how agents spend anyway: a known amount, for a known purchase, right now.

The pattern: exact total in, card number out

The reliable flow in production today: the agent navigates to the merchant checkout and determines the exact total including tax and shipping. It then pays a single x402 request for a card loaded with exactly that amount, waits a few seconds for the card details, and completes the merchant checkout like any cardholder. Because the card is non-reloadable and holds only the checkout total, the merchant can never charge more than the agent intended to spend. The card is the budget.

x402 is the piece that makes this autonomous. It revives HTTP status 402: the server answers an unpaid request with a price quote, the client pays in stablecoins and replays the request with a payment header. No account creation, no checkout page, no human. If you have not met the protocol, the protocol comparison covers where it fits; the short version is that x402 is the standard for machine-to-machine payments, with the x402 Foundation under the Linux Foundation stewarding it.

The 60-second version, with real requests

Order a $50 card. The first call, with no payment attached, returns the x402 challenge quoting the exact price:

curl "https://laso.finance/get-card?amount=50"
# HTTP/1.1 402 Payment Required
# body: { "accepts": [ ...price, network, and recipient for USDC on Base or Solana... ] }

Pay it and replay. Any x402 client library handles the challenge automatically; with x402-fetch and a funded wallet it is a wrapped fetch call:

import { wrapFetchWithPayment } from "x402-fetch";

const fetchWithPay = wrapFetchWithPayment(fetch, walletClient);
const res = await fetchWithPay("https://laso.finance/get-card?amount=50");
const { auth, card } = await res.json();
// card: { "card_id": "card_abc123", "usd_amount": 50, "status": "pending" }
// auth: { "id_token": "eyJ...", "refresh_token": "AMf...", "expires_in": "3600" }

The response deliberately does not contain the card number. Poll the free /get-card-data endpoint with the returned Bearer token every 2 to 3 seconds; status flips from pending to ready in roughly 7 to 10 seconds:

curl "https://laso.finance/get-card-data?card_id=card_abc123" \
  -H "Authorization: Bearer eyJ..."
# {
#   "card_id": "card_abc123",
#   "status": "ready",
#   "usd_amount": 50,
#   "card_details": {
#     "card_number": "4111111111111111",
#     "exp_month": "12",
#     "exp_year": "2027",
#     "cvv": "123",
#     "available_balance": 50,
#     "billing_address": { "name": "Laso Finance", "zip": "91723", "required": false, "...": "..." }
#   }
# }

That is the whole loop: one paid call, one polled call, and the agent holds a spendable card number, expiry, CVV, and a known-good billing address for merchants that ask for one. When the token expires after an hour, POST /auth with grant_type=refresh_token renews it for free. The step-by-step tutorial with every response field is at Issue a virtual card with one x402 call.

How the agent pays: three wallet options

• An x402 wallet the agent already has. Wallets from Locus, Sponge, or Ampersend settle Laso endpoints today with no Laso key needed (Laso ships as a default skill on Ampersend). If your agent stack includes one, use it.
• A self-custody wallet you fund. Any wallet holding USDC on Base or Solana works with a standard x402 client library. You hold the key; the agent signs payments with it.
• A Laso-managed wallet. For agents with no wallet at all: a human opens the agent dashboard once, approves the wallet, and hands the agent a key. The agent then calls agentX402Pay and Laso signs and settles on its behalf, on Laso endpoints or any external x402 endpoint, with a per-call spend cap the caller pins. The agent never holds a private key.

What this does not require, and what it does

Ordering a card requires no identity documents: the checks on a card order are that the amount is within $5 to $1,000, the x402 payment settles, and the account is not frozen. Identity verification exists in the product but is scoped per feature (Venmo and PayPal payouts require it), and it is the one step an agent cannot perform: the API returns a verification link for the agent to hand to its human, and everything else stays agent-drivable. Cards are U.S.-merchant only at the $5 to $1,000 size; international cards ($100 to $1,000, 3.8% fee) are queued and fulfilled within about 24 hours rather than instantly. Those are the real constraints; plan around them rather than discovering them mid-purchase.

Beyond the card: the rest of an agent’s financial stack

A card for arbitrary checkouts is usually the first thing an agent needs, and rarely the last. The same API and the same USDC balance cover gift cards for 2,000+ brands (/search-gift-cards, /order-gift-card), payouts to a human’s Venmo, PayPal, debit card, or bank account, real U.S. bank rails the agent can provision for its account (routing and account numbers over the API), webhooks instead of polling, and withdrawal back to the funding wallet. The full map is at Financial tools for AI agents, and the machine-readable version an agent can bootstrap from is laso.finance/SKILL.md.

Honest alternatives

If you are a company issuing cards to your own product’s users, a business issuing platform with its own onboarding (Stripe Issuing and similar) is the right tool, and the Stripe Issuing comparison takes that seriously rather than dismissing it. If your agent only ever buys from services that natively speak x402, it does not need a card at all; a funded wallet is enough. The card matters because most of the commercial web does not speak x402 and simply wants a card number. That bridge, from an x402 payment to a card that works at any checkout, is the part only Laso provides today.

Frequently asked questions

Can an AI agent get a credit card?

Not a literal credit card: no issuer underwrites credit for autonomous software as of 2026. An agent can programmatically obtain a virtual prepaid card in about a minute by paying an x402 request in USDC, which covers the actual need: a card number that works at checkout.

How does an AI agent pay for things online?

The working pattern: determine the exact checkout total, pay one x402 request for a prepaid card loaded with that amount (GET /get-card on Laso), poll GET /get-card-data for the card number, expiry, and CVV, then complete the merchant checkout normally. Services that natively speak x402 can be paid directly, without a card.

Does the agent need to complete KYC to get a card?

No identity documents are involved in a card order. The order clears three checks: the amount is $5 to $1,000, the x402 payment settles, and the account is not frozen. Identity verification is scoped to specific features (Venmo and PayPal payouts), where the agent receives a link to pass to its human.

What does it cost to give an agent a card?

U.S. cards carry a 0% Laso fee: a $50 card costs $50 in USDC. International cards add a 3.8% fee plus about 2% FX on non-USD transactions. The x402 challenge quotes the exact fee-inclusive total before anything is paid, so the agent always knows the price in advance.

Can the agent spend more than I intend it to?

Not through the card: each card is non-reloadable and holds exactly the amount ordered, so a merchant cannot charge beyond it. Spending control shifts to funding: the agent can only order cards up to the USDC it can pay with, and the managed-wallet path adds a per-call cap (maxAmountUsdc) the caller pins before anything is signed.

What is the fastest way to set this up?

Point your agent at https://laso.finance/SKILL.md and it can set itself up: the file contains the full flow in agent-readable form, including wallet setup, ordering, polling, and error handling. A human is needed once, only if the agent has no wallet: approving a managed wallet from the dashboard takes about a minute.

More guides

• x402 vs AP2 vs ACP vs MPP vs UCP: which should your agent use? — All five agent payment protocols compared honestly: x402 and MPP for machine-to-machine HTTP payments, ACP for ChatGPT checkout, UCP for Google surfaces, AP2 for authorization. Which layer each one is, when to use each, and a worked x402 example.
• x402 vs Stripe Issuing for AI agents — Two real ways to put a card in an AI agent’s hands: Stripe Issuing behind a business account, or x402 card issuance the agent drives itself. An honest comparison of onboarding, funding, controls, and when each wins.
• Issue a virtual card with one x402 call — A complete, runnable walkthrough: pay one x402 request in USDC and receive a virtual prepaid card with number, expiry, and CVV. Real endpoints, real response shapes, error handling included.
• All agent guides, or how Laso compares to the alternatives