# Delegated Payments: When an AI Agent Pays for You

> What delegated payments are in agentic commerce, how ACP with Stripe and Google's AP2 handle them, and what changes for the store that gets paid.

URL: https://clione.ai/glossary/delegated-payments/
Lang: en

Delegating a payment is not handing someone your card, or a direct debit, or paying on a third party's behalf in the accounting sense. In [agentic commerce](/glossary/agentic-commerce/) it is something else: **an [AI agent](/glossary/ai-agent/) pays for a person with a permission that expires and has a cap**, and the store gets paid without ever seeing the full card. It matters to a store because the order arrives with that permission instead of a customer typing in a card number, and the store needs to know what it can charge with it and who is responsible if something goes wrong.

## How it works

The problem it solves is the same in every protocol: the agent has to be able to pay, but it must not be able to spend whatever it wants, wherever it wants, whenever it wants. Today there are two published ways to do it.

### In ACP: a single-use credential

OpenAI and Stripe's [ACP (Agentic Commerce Protocol)](/glossary/acp/) has a dedicated piece, the Delegated Payment Spec, which lets OpenAI securely share payment details with the merchant or with its payment service provider.[^openai-delegated-payment] The flow goes like this: the buyer picks their payment method in ChatGPT, the details travel directly to the store's payment provider or its credential vault, that provider returns a credential and OpenAI forwards it when the purchase is completed.[^openai-delegated-payment]

That credential carries its limits in an object called _allowance_: the reason (for now only `one_time`, a single use), the maximum amount, the currency, the checkout session, the merchant and the expiry date. **It is single-use and is not valid above that amount or after that date.**[^openai-delegated-payment] OpenAI is not the seller: each merchant brings its own payment provider, and the first implementation compatible with this specification is Stripe's, with more providers announced.[^openai-acp-concepts]

At Stripe, that credential is a limited grant to use the customer's payment method: the agent grants it to the seller's Stripe profile, **with usage and expiry limits**, and the agent sets the maximum amount to match the purchase total. The seller only sees limited details of the payment method, such as the card brand and its last four digits, and the agent can revoke the grant. Stripe offers it in the United States, Canada and several European countries.[^stripe-spt]

### In AP2: a signed permission with conditions

[AP2 (Agent Payments Protocol)](/glossary/ap2/) starts from a different idea: instead of one credential per purchase, the person signs a set of conditions and the agent buys within them. In the flow where the person is not there (_Human Not Present_), they approve open mandates with their limits on a trusted screen and leave; the agent then builds the order, signs the closed mandates itself with its key, and the credential provider verifies them before handing over the payment credential.[^ap2-flows] Each of those records is an [AP2 mandate](/glossary/ap2-mandate/).

The conditions of the payment mandate can set **an amount range, a total budget, how many times the agent can repeat, who it can pay, with which method and on which dates**.[^ap2-payment-mandate] Version 0.2, published on April 28, 2026, focuses precisely on these purchases made without the person there.[^ap2-releases]

|                         | ACP (delegated payment)                                                           | AP2 (person not present)                                                                               |
| ----------------------- | --------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------ |
| What the store receives | A single-use credential[^openai-delegated-payment]                                | The mandates and a payment credential verified by the credential provider[^ap2-flows]                  |
| What limits it          | Maximum amount, currency, merchant, session and expiry[^openai-delegated-payment] | The signed restrictions: amounts, budget, repetitions, payees, methods and dates[^ap2-payment-mandate] |
| Repeated use            | No: single use[^openai-delegated-payment]                                         | Possible, if the mandate allows it and within the budget[^ap2-payment-mandate]                         |
| Who gets paid           | The store's payment provider[^openai-acp-concepts]                                | The store's payment processor[^ap2-flows]                                                              |

## In a store

A **made-up example**: an office supplies store that takes payments with Stripe receives an order placed from an ACP-compatible assistant. What happens, according to Stripe's documentation:[^stripe-spt]

| Step | Who      | What happens                                                                                                 |
| ---- | -------- | ------------------------------------------------------------------------------------------------------------ |
| 1    | Customer | Picks the card they want to pay with in the assistant                                                        |
| 2    | Agent    | Grants the store's Stripe profile a credential limited to that purchase, with a maximum amount and an expiry |
| 3    | Store    | Receives the order and the credential, and uses it to create the charge (a PaymentIntent)                    |
| 4    | Stripe   | Processes the payment; from there, refunds and reports work as with any other payment method                 |
| 5    | Stripe   | Notifies the store and the agent when the credential is deactivated: used, expired or revoked                |

And this is the object the store can look up, as it appears in Stripe's documentation (not a real order):[^stripe-spt]

```json
{
  "id": "spt_123",
  "object": "shared_payment.granted_token",
  "deactivated_at": null,
  "usage_limits": {
    "currency": "usd",
    "expires_at": 1793896955,
    "max_amount": 1000
  }
}
```

**The store does not see the card, but it does see the limits**: the currency, the maximum amount in the currency's smallest unit and the expiry date.


Believing that with a delegated payment the assistant becomes the seller or the one answerable for the charge. In ACP, OpenAI is not the seller and each merchant brings its own payment provider;[^openai-acp-concepts] **settlement, refunds and chargebacks are still the store's**.[^openai-delegated-payment] Delegating the payment changes who presses the button, not who sells.


## How to check it

1. **Ask your payment provider** whether it supports delegated credentials for agents. In ACP, the first compatible implementation is Stripe's.[^openai-acp-concepts]
2. **If you take payments with Stripe, check your country on its list** and create your Stripe profile, which is who the agent grants the credential to.[^stripe-spt]
3. **Try the flow in test mode** before receiving real orders: Stripe documents how to simulate a credential with its currency, its maximum amount and its expiry.[^stripe-spt]
4. **Review your refund and chargeback process**: it does not change, and it is still yours.[^openai-delegated-payment]
5. **For AP2, look at the published version** in the official repository and ask your gateway whether it verifies its mandates.[^ap2-releases]

## Related concept: agentic checkout

[Agentic checkout](/glossary/agentic-checkout/) is the entire purchase made by an agent: the cart, shipping, taxes and payment. In ACP, for example, ChatGPT collects the buyer's details, the delivery details and the payment details and calls the store's endpoints, and the store validates the order, calculates the taxes and processes the charge in its own systems.[^openai-acp-concepts] **Delegated payment is only the last piece**: the one that lets you get paid without the agent holding the card. A store can prepare its checkout for agents and decide separately which provider and what limits it accepts delegated payments with.

To go further, the [AP2 mandate](/glossary/ap2-mandate/) goes down to the detail of the signed conditions and the [agentic commerce reading path](/learn/agentic-commerce/) orders the rest of the vocabulary.