---
title: Pay looot from your agent
description: Which ways an agent can pay for looot credit today, which are untested, and which are not built yet, with the steps for the one that works.
---
looot runs on prepaid credit. When the balance is too low, someone has to pay a top-up. This page
says which ways an agent can do that itself, and how sure we are about each one.
| Way to pay | Status | What the agent needs |
| --- | --- | --- |
| [The Stripe Checkout link](#the-stripe-checkout-link) | Works today | The `top_up` tool, and a person or a browser tool to pay the page |
| [A one-time agent card on the Checkout page](#a-one-time-agent-card-on-the-checkout-page) | Untested | A card from a card-issuing service for agents, and a browser tool |
| [A Stripe Link agent wallet](#a-stripe-link-agent-wallet) | Not built yet | A shared payment token; looot has no route that takes one |
| [An x402 wallet, pay per call](#an-x402-wallet-pay-per-call) | Not built yet | A wallet that signs x402 payments; looot does not answer in x402 |
"Works today" means we ran it and the credit landed. "Untested" means it should work but nobody
has run it yet, so this page gives no steps for it. "Not built yet" means looot cannot take that
payment today.
## When you need it
- A new workspace starts at $0, so the first paid run needs a top-up. See
[Before your first run](/money#before-your-first-run).
- A run is refused with [`insufficient_balance`](/errors/rest-errors#insufficient_balance) when the
balance cannot cover its hold.
- The minimum top-up is not written on this page. It comes from the gateway: `balance` returns it
as `topUpLink.minimumUsd`, and `looot balance` prints it.
looot never sees card details. Stripe hosts the payment page, and no looot API takes a card number.
## The Stripe Checkout link
Status: **Works today**
An agent token cannot charge a card. It asks for a Stripe Checkout link, and whoever holds the
card pays on that page.
1. Check the balance and the minimum.
```json MCP
balance {}
```
```bash CLI
looot balance
# prints the balance, the minimum top-up and the top-up link
```
2. Get a Checkout link. `amountUsd` is optional; without it, looot suggests an amount of at least
`topUpLink.minimumUsd`.
```json MCP
top_up { "amountUsd": 25 }
```
```bash CLI
looot balance
# read topUpLink.checkoutUrl or topUpLink.dashboardUrl from the output
```
The [`top_up`](/mcp-tools/top-up) answer carries `checkoutUrl`:
```json
{
"checkoutUrl": "https://checkout.stripe.com/c/pay/cs_test_a1b2c3d4",
"topUpId": "topup_9f8e7d6c5b4a3928",
"amountUsd": 25,
"dashboardUrl": "https://looot.ai/usage?top_up=1"
}
```
3. Pay on the `checkoutUrl` page. Most agents hand the link to their person. When `checkoutUrl`
is `null`, the answer has a `reason`; send the person to `dashboardUrl` instead.
4. Call `balance` again. The credit shows once Stripe confirms the payment, not when the page opens.
5. Run the call again with a **new** idempotency key. A run refused for `insufficient_balance` is
not retried for you.
Asking again for the same amount within 10 minutes returns the same link, and a workspace can open
at most 3 new Checkout sessions per hour. The [Top up](/money/top-up) page lists the errors.
## A one-time agent card on the Checkout page
Status: **Untested**
Some card-issuing services give an agent a one-time card number for a single purchase. An agent
that holds such a card and a browser tool could open the `checkoutUrl` from the section above and
type the card into the Stripe page itself. Nobody has run this on looot yet, so there are no
steps here. If you try it, expect this:
- The card must cover the full top-up amount, and the amount must be at least
`topUpLink.minimumUsd`.
- The card's bank may ask for a 3D Secure check on the Stripe page. The agent then needs the code
its card service gives for that check.
- Stripe may block the payment. looot does not see why; the Stripe page shows the error.
- Checkout saves the card for auto top-up. A one-time card is dead after the first charge, so an
auto top-up on it fails. Turn auto top-up off on [looot.ai/usage](https://looot.ai/usage)
before you pay with a one-time card.
## A Stripe Link agent wallet
Status: **Not built yet**
A Stripe Link agent wallet can hand a seller a shared payment token instead of a card number, with
no browser. looot has no route that accepts a shared payment token today, so an agent with only a
Link wallet still needs the Checkout link above. This page will say when it works.
## An x402 wallet, pay per call
Status: **Not built yet**
x402 is an open protocol: the seller answers HTTP 402 with payment terms, and the agent's wallet
signs a stablecoin payment for that one call, with no account. looot answers 402 with
`insufficient_balance` and a top-up link, not with x402 terms, and every run needs a looot
workspace. This page will say when it works.