Apple Pay-Style Approvals for AI Agents: Native In-App Checkout Consent
Key takeaways
- A native approval is a consent card that the agent product renders inside its own interface. The user confirms it with a passkey or biometric and does not leave the conversation.
- A redirect to a hosted checkout page breaks the conversation, adds screens where users abandon, and removes the agent's view of what happens next.
- The pattern follows Apple Pay: the user sees the merchant and the total, then confirms with one gesture that is already familiar, such as Face ID or Touch ID.
- The approval card shows line items, the total, the merchant, and fulfillment details, so consent covers one specific purchase and not a general permission to spend.
- Approval at the time of intent, not at checkout, lets the user close the app while the agent completes the purchase, and it makes scheduled purchases possible.
A native checkout approval for an AI agent is a scoped consent card that renders inside the agent product's own app, shows the exact line items, total, and merchant, and is confirmed with a passkey or biometric in the same way Apple Pay asks for a double-click. It replaces the redirect to a hosted checkout page. The user stays in the conversation, and the purchase runs after the approval.
Why does a redirect hurt an agent checkout?
A redirect hurts an agent checkout because it moves the user out of the conversation and into an interface that has none of its context. On the web, a new page was a small cost, because the browser was already the application. Inside an agent, a redirect is a switch to a different product.
- The conversation breaks: The user was talking to an agent about a dinner order or a flight. A hosted page shows a form with none of that context, and the agent cannot see what happens next.
- Each extra screen loses users: Every screen between intent and confirmation is a place to abandon. On mobile, a redirect often adds an app switch, a login, and a keyboard.
- The brand changes: A hosted checkout page shows the brand of whoever built it. A user who trusted an assistant now sees an unfamiliar payment brand that asks for card details.
- Forms are work the agent should do: Checkout pages are forms for human hands and eyes. If the human must complete the form, the task was not delegated.
What does a native approval look like?
A native approval is a small consent surface inside the product's own UI, where the user reads the proposed purchase and confirms it with a gesture they already use for payments and sign-in. The flow has five steps.
- 1
The agent drafts the purchase: A request such as "order dinner for four" becomes structured terms: items, quantities, prices, fees, a total, and the merchant.
- 2
The product renders the approval card: The card uses the product's own components and styles, so it looks like part of the app and not like an embedded third party.
- 3
The user confirms with a passkey or biometric: Face ID, Touch ID, or a platform passkey. One deliberate gesture, bound to this set of terms.
- 4
The purchase runs against the merchant: After approval, the system completes the purchase with the user's card and checks execution against the approved terms.
- 5
The result returns to the conversation: Order status and confirmation arrive in the same thread, so the agent can continue: track the delivery, add a calendar entry, or book the next leg.
What information should an approval card show?
An approval card should show the line items, the total, the merchant, the fulfillment details, and the scope of the approval. Specific terms make the consent meaningful: the user agrees to one described purchase, not to a general permission to spend.
- Line items: Each product or service, with quantity and unit price, so the user sees two burritos and a delivery fee and not one opaque number.
- Total amount: The full charge with taxes, fees, tips, and shipping where they are known, plus the maximum for any amount that can vary.
- Merchant: The business that will be paid. Users check that dinner comes from the restaurant they named.
- Fulfillment details: The delivery address, pickup window, travel dates, or reservation time, as the purchase type requires.
- Scope: What the agent may do with this approval, and nothing more. In effect, the approval card is a receipt issued before the purchase.
What happens after the user approves?
After the user approves, the approved terms become the limit for the purchase, the purchase runs on the user's card, and the result returns to the conversation.
- 1
The approved terms become the boundary: The system stores the approval as a structured record and checks each execution step against it, not only once at the start.
- 2
Checkout runs without the user: The system completes the merchant interaction. The agent works with a tokenized card and does not see the card number.
- 3
The charge lands on the user's own card: The statement, the bank app, and the dispute path stay where the user expects them.
- 4
The outcome flows back: The agent receives the result and order details and reports progress. If something changes materially, the purchase stops and the user is asked again.
Why can the user close the app after approving?
The user can close the app after approving because approval happens when the purchase terms are set, not at the moment of checkout. In a traditional flow, payment is the last step of a live session, so the person must stay until the order goes through. With approval at intent time, the user's part ends at the confirmation, and the system completes the checkout and reports the result when the order is placed.
This separation also makes future purchases possible. A user can approve scoped terms for concert tickets that go on sale next week, close the app, and let the agent buy when the sale opens. The Agent Payments Protocol (AP2), which Google introduced, describes a similar idea, where a signed mandate records what the user authorized before the agent acts.
How does a native approval compare with a hosted checkout page?
A native approval keeps the user, the brand, and the agent's context inside the product, while a hosted checkout page moves all three somewhere else.
| Dimension | Hosted checkout page | Native approval |
|---|---|---|
| Where the user is | Redirected to a third-party page or browser | Inside the product's app or conversation |
| Which brand shows | The payment provider's | The agent product's own |
| What consent covers | A payment on a page, often with card entry | Specific line items, total, and merchant |
| Confirmation gesture | Forms, logins, sometimes a one-time code | Passkey or biometric, as in Apple Pay |
| Agent visibility | Lost once the user leaves | Kept, and the agent reports the outcome |
| Mobile behavior | App switch, keyboard, extra taps | One in-app confirmation |
Hosted checkout was designed for a person in front of a browser. In agentic commerce, the person approves a decision and does not fill in a form, so the interface should be a consent surface and not a data-entry surface.
Why keep your own brand on the approval?
Keeping your own brand on the approval avoids a trust cost: a third-party payments brand that appears in the middle of a purchase makes users hesitate. When the approval is a component in the product's own UI, the user sees one consistent product from request to receipt.
- No interstitial pages: The approval renders in the product's surface, with no redirect to a payments domain during the purchase.
- The product controls the design: The infrastructure supplies the terms and the confirmation checks. The product supplies the visual design and the copy.
- The user's card and bank stay in place: Because the purchase runs on the user's existing card, the statement, the cardholder protections, and the dispute path do not change.
Does native approval work in chat, messaging apps, and the web?
Native approval works in chat, messaging apps, and the web, because the approval is defined by its terms and its confirmation, not by a page.
- In-app chat: The approval appears as a card in the message stream, next to the request that produced it, and the confirmation arrives in the same stream.
- Messaging apps: A link out of the thread loses users, so keep the summary in the message and make the confirmation step as short as the platform allows.
- Web and native apps: The approval is a component in the product's UI and uses the platform passkey or biometric that the user already has enrolled.
Passkeys follow the FIDO2 and WebAuthn standards. The private key stays on the user's devices, the site stores only a public key, and each passkey is bound to the site that created it, which resists phishing.
How do you add native approvals to an agent?
To add native approvals to an agent, turn each request into structured terms, render them in your own component, confirm with a passkey or biometric, and execute only within the approved terms.
- 1
Turn the request into structured terms: Record the merchant, items, quantities, prices, total, fulfillment details, and an expiry.
- 2
Render the terms in your own approval card: Show the merchant and total first, then the items, and wire the confirm action to a passkey or biometric.
- 3
Store the approval as a record: Keep the approved terms and the confirmation together, so execution and any later dispute can refer to them.
- 4
Execute and report in the conversation: Complete the purchase on a tokenized card and send status and confirmation back to the same thread.
- 5
Handle edge cases explicitly: Resolve price changes, out-of-stock items, and cancellations against the approved terms, and ask the user again when something material changes.
A native approval is the difference between an agent that recommends a purchase and an agent that completes one. Keep the user in the product, show exactly what they agree to, take one familiar gesture, and run the purchase within those terms.
Frequently asked questions
What is an Apple Pay-style approval for an AI agent?
An Apple Pay-style approval for an AI agent is a consent prompt that renders inside the agent app, shows the exact items, total, and merchant, and takes one passkey or biometric confirmation. The user approves one specific purchase with a familiar gesture and does not leave the conversation.
Why are redirects bad for AI agent checkout?
Redirects are bad for AI agent checkout because they move the user out of the conversation into a hosted page with none of its context. They add screens, logins, and app switches where users abandon, and the agent can no longer see what happens next.
What should a user confirm in an agent purchase approval?
In an agent purchase approval, the user should confirm structured terms: line items with quantities and prices, the total, the merchant, and fulfillment details such as an address or reservation time. The approval should cover that purchase only, and execution should stay within those terms.
Why confirm an agent purchase with a passkey or biometric?
A passkey or biometric shows that the user, on their own device, agreed to the specific terms. Passkeys use the FIDO2 and WebAuthn standards, keep the private key on the user's devices, and resist phishing, so a stolen password cannot approve a purchase.
Does the user need to stay in the app until the purchase completes?
No. When approval happens at the time the terms are set, the user can close the app after confirming. The agent completes the purchase within the approved terms and reports the result in the same conversation.
Related articles