AI Engineer World's Fair 2026
How AI Agents Pay: Checkout in ChatGPT and Google AI Mode — Sam Parsons, PayPal
Read the talk
How AI Agents Pay: Checkout in ChatGPT and Google AI Mode
Sam Parsons explains three routes from an agent-assisted shopping session to a merchant charge—and how tokenization lets new checkout experiences use existing PayPal Enterprise Payments processing.
From a talk by Sam Parsons
At a glance
Ideas worth remembering
ChatGPT’s demonstrated ACP path separates merchant-built discovery from host-provided checkout, then delivers a payment token to the merchant’s MCP server for processing.
Tokenization replaces the card credential in the merchant handoff. The described tokens are constrained by merchant, maximum amount, currency and expiration, and transactions retain their checkout-source attribution.
Google AI Mode uses merchant-owned UCP sessions, public processor configuration and completion endpoints instead of a merchant-built MCP app; Google Pay supplies the tokenization route.
External checkout offers control over the payment experience and methods, at the cost of leaving the agent. A merchant session and completion communication let the MCP app reflect the finished order.
Three ways to reach the merchant’s payment system
A customer can discover a product inside an agent, decide to buy it there, and still have the merchant process the payment through its existing system. The engineering problem is connecting those steps: who presents the products, who collects the payment credential, and what reaches the merchant when checkout finishes? Sam Parsons, a senior staff engineer at PayPal, walks through that connection using PayPal Enterprise Payments—the business previously known as Braintree.
The recording follows three paths:
- ChatGPT Instant Checkout: an MCP app provides the merchant’s shopping interface, then invokes checkout through the Agentic Commerce Protocol (ACP).
- Google AI Mode: the Universal Commerce Protocol (UCP) connects the agent to merchant endpoints, with Google Pay handling the payment-tokenization path.
- An MCP app with external checkout: the shopping interface lives inside the agent, while payment happens on a separate page under the merchant’s control.
Parsons describes ACP and UCP as very similar at this early stage. The practical differences emerge in the interface the merchant builds and the route by which checkout returns a payment token.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
ChatGPT: the merchant owns discovery, the host presents checkout
An MCP app adds a rendered interface to an MCP server: HTML and JavaScript can appear inside a supporting agent host. In the examples here, ChatGPT calls this an app and Claude calls it a connector. That interface lets the merchant decide how products appear and how the customer interacts with them. Instant Checkout supplies the next step: an in-chat purchase initiated from that merchant-built interface.
The hotel-booking demonstration makes the division concrete. A customer searches for hotels in ChatGPT, and the travel app presents options through the merchant’s UI. The merchant can shape that interface around the thing being sold; a hotel search need not look like a generic chat response. When the customer selects Proceed to Checkout, the interface changes to ChatGPT’s Instant Checkout experience. The merchant built the discovery screen, while the host supplies the payment screen.
That transition also changes which component does the work. The MCP app asks its host to start a purchase using ACP. The user supplies a card or uses a stored payment credential; the checkout path tokenizes it through PayPal Enterprise Payments. Checkout then sends the resulting token to the merchant, which performs the charge. The app initiates the purchase, but the merchant remains the component that processes the transaction.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
A card becomes a constrained token, then a confirmed booking
In the hotel demo, the customer enters a test credit card number into the host’s checkout. Tokenization exchanges that transactable credential for a token: a representation the merchant can submit for payment without receiving the original card number through this flow. Parsons describes this as avoiding an increase in PCI scope from passing the token around. That claim concerns the token handoff; it does not remove the merchant’s existing payment-compliance responsibilities.
The host coordinates tokenization with PayPal Enterprise Payments and receives the token back. It then passes the token to the merchant, which processes it using its usual payment integration. The visible result is a return to the hotel app with the booking confirmed. The causal sequence matters: entering a card does not itself update the booking interface. Tokenization supplies a usable payment reference, the merchant transacts with that reference, and the app reflects the completed booking.
Where does the card credential stop, and where does the merchant’s existing processing begin? The flow below separates credential exchange from token delivery and the final UI update. It shows why the merchant can receive a new checkout source while continuing to process a familiar kind of payment token.
The merchant implements two integration points:
- Start checkout in the widget. JavaScript inside the MCP app triggers the host’s Instant Checkout experience.
- Receive completion on the server. A checkout-completion tool call reaches the merchant’s MCP server with the payment token. The server can then process it as a typical PayPal Enterprise Payments token.
These touchpoints keep the payment handoff small, but building the MCP app is still real integration work. Settlements, refunds, chargebacks and compliance continue through the existing PayPal Enterprise Payments operation.
The token also limits what can be charged:
- Merchant: it can be processed only for a given merchant.
- Maximum amount: it carries a spending ceiling.
- Currency: it specifies the currency of the payment.
- Expiration: it cannot remain usable indefinitely.
These constraints limit the token’s permitted use after it leaves the checkout component. Transactions also retain their source attribution, so this payment appears in PayPal Enterprise Payments as a ChatGPT-originated transaction.
Presents hotels and a Proceed to Checkout action inside ChatGPT.
The host exchanges the card credential for a token. The merchant receives that token, processes the payment, and the hotel app returns with a confirmed booking.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Google AI Mode: publish products and endpoints instead of an app UI
Google AI Mode reaches a similar payment outcome through a different shopping integration. In the running-shoes example, the agent uses UCP to create a checkout session for the user against the merchant. That session belongs to the merchant and provides the entity through which checkout progresses. When the customer chooses to pay, Google Pay tokenizes the payment through PayPal Enterprise Payments. Completion delivers the token to the merchant, which submits it with the transaction information to perform the charge.
The key implementation difference is the absence of a merchant-built MCP app. This integration supplies products and checkout endpoints; it does not require the merchant to design an interface inside Google AI Mode. That removes the app-UI work from this path while leaving the merchant responsible for the endpoints that receive and complete checkout.
The two main touchpoints are configuration and completion:
- Declare the payment processor. A well-known UCP JSON file identifies Braintree or PayPal Enterprise Payments and supplies the merchant ID and client key. Parsons describes that client key as suitable for public exposure; the configuration described here is not a request to publish a private processing credential.
- Handle the completed session. A completion call reaches the merchant endpoint with the checkout session ID and the token representing the card behind the Google Pay payment. The merchant uses it to process the transaction.
The token arrives through Google rather than ChatGPT, but settlement, refunds, chargeback risk and compliance remain part of the merchant’s ordinary payment operation.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
External checkout gives the merchant the whole payment experience
The third path uses an MCP app for shopping and a separate page for checkout. A product card and checkout button appear inside the agent. Clicking the button opens an external checkout page, where the merchant controls the experience and payment-method choices. The cost is an extra transition: the customer leaves the agent to finish paying.
In the Claude demonstration, the connector loads the merchant-designed shopping interface. The customer picks an item and clicks Checkout, which opens an external link tied to a merchant session. That session connects the purchase shown inside Claude to the checkout performed outside it. After payment completes, the MCP app updates automatically with the order status. Communication behind the scenes carries completion back to the app; the recording does not specify the transport or synchronization implementation.
How can an app inside an agent reflect a purchase completed on another page? The diagram follows the shared session across the handoff and the returning status update. The useful relationship is continuity of the order: checkout moves elsewhere, but the app can still show what happened to the purchase it started.
Shows the merchant’s products and checkout button.
The customer leaves the agent to pay. Completion communication updates the original MCP app with the order status.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Choose by destination, UI ownership and checkout friction
Parsons closes with elicitation as a possible improvement to the external handoff. At the time of the recording, he says most major hosts do not yet support it. He presents it as a way to request external validation more smoothly, potentially through an iframe-like experience. It is a prospective improvement; the external-page demonstration is the working path shown here.
The choice follows the customer destination and the control the merchant needs:
- For ChatGPT with a custom shopping interface: build the MCP app and connect it to Instant Checkout through ACP. The merchant shapes discovery and receives a token to process; the host presents checkout.
- For Google AI Mode without building an in-agent UI: provide products, UCP configuration and checkout endpoints. Google Pay supplies the tokenization route.
- For control over the full checkout experience: use an MCP app with an external page and connect the two through a merchant session. The merchant gains control over payment choices while accepting the friction of leaving the agent.
Across the first two paths, new checkout channels feed tokens into familiar merchant processing. The third extends the merchant’s own checkout into an agent-assisted shopping journey. The decision is where to place the customer experience and how much of it to build.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Read the complete timestamped transcript
- 0:12
Okay, so I'm gonna talk to you about agentic commerce, um, with PayPal Enterprise Payments. So this is about how do we accept payments from agents, kind of maybe a human in the loop, maybe not, um, for merchants. So I'm from PayPal, um, and I work on our agentic commerce area. Um, my name's Sam Parsons, a senior staff engineer here. Um, so first of all, you may have heard of Braintree before, and Braintree is PayPal's large
- 0:42
enterprise payments. What's that?
- 0:46
Braintree.
- 0:47
Braintree. Heart Braintree. Yes. Uh, so but now it's PayPal Enterprise Payments. So I'm gonna say PayPal Enterprise Payments, but if you know it as Braintree, uh, it's the same thing. So we handle payments for really large corporations, you know, think of the biggest ones that you can think of, huge volume, huge scale. So what we're gonna talk about here is a couple of things, three different paths, and really the, the key takeaway that I want you to have is that PayPal Enterprise Payments is building the bridges for merchants to be able to
- 1:16
accept payments from many different places. And so I'm gonna give you a flavor of some of them, but really this, this is in a fast evolving area. You're gonna see way more, um, over the coming months and, and year. So first of all, we're gonna talk about agentic commerce protocol. So this is, uh, OpenAI has created that, and that'll be in ChatGPT. You can use this. Universal commerce protocol, Google partnered with some others and created that protocol, and these are very similar. So if you go
- 1:46
look at the specs, you're gonna find out, oh, they are almost identical. Um, and again, you know, we're, we're kind of at early days here. But also, we're gonna demo for you another path towards accepting agentic payments, human in the loop, using just MCP apps and, and external checkout. Okay? So let's dive in. Um, so first of all, this is Instant Checkout in ChatGPT using agentic commerce protocol. So PayPal Enterprise Payments build an integration to agentic commerce
- 2:16
protocol that allows you to start taking payments in this manner. So there's a couple different flavors. The one I'm gonna walk through uses an MCP app. So an MCP app is like an MCP server, but you embed inside of that app, you embed UI, so it has HTML, JavaScript, and things like that. And those then can get rendered inside of different agents. So ChatGPT can render those. You can add an app. You can render them in Claude. You call that a connector.
- 2:47
Same thing, it's an MCP app. And this extension, many a different agents out there, you know, Goose or other ones also support. So this is kind of a, a general standard. Instant Checkout allows us within ChatGPT to trigger, like, an in-chat purchase of something. Okay? So let me kinda walk through what that flow looks like. So first of all, the user will have their intent, so they're searching in ChatGPT. They'd like to buy
- 3:16
something and move to the next part. There's discovery there, so the merchant using an MCP app can show to the user, "Here's things that you may want to purchase." They get to control that experience. So it's inside of, say, ChatGPT, but the merchant gets to control it. They get to control the look, the feel. They get to control what's showing up and interact there. Then when the user decides, "I'd like to go to the next step and buy this," they can trigger this checkout.
- 3:46
So that's where the MCP app talks to its kinda host, ChatGPT, and says, "I'd like to purchase something." That uses agentic commerce protocol. Behind the scenes, the user would enter in maybe a credit card, or maybe they have that stored, and move to the next part. That would get tokenized against PayPal systems, PayPal Enterprise Payments. And finally, when we get to the end of that, they'll complete that and send that across to the merchant, who then charges that. So we kinda look at this big life cycle. At the end of
- 4:16
it, from the merchant's perspective, they do a couple of things as far as bridging that gap. They're pr- providing these MCP app experience to the user, but they're also providing... They're receiving these tokens that come from, ultimately, PayPal Enterprise Payments, and that looks like every token they normally process. So this is a really seamless integration for them at the end of it. And on the back of it, settlements, refunds, chargebacks, compliance, all of that remains the same and is
- 4:46
supported through PayPal Enterprise Payments in general. So right now we're just gonna do a, a walkthrough of searching here in ChatGPT. This will give you that Instant Checkout experience. So this one here is, like, a travel app. So I'd like to buy some, um, looking for some hotels. Um, here's some different options, and I'll just pause here. So you can see this UI here is not a ChatGPT UI. This is controlled by the merchant. Merchant gets to specify
- 5:16
that. They can have their interface for what makes sense, depending on what they're selling. Um, sorry. That
- 5:24
fast-forwarded through there.
- 5:27
Hit play. And so then we continue here. When they're ready, they go to Proceed to Checkout. This now is pulling up the ChatGPT Instant Checkout experience inside of there. So the, uh, the merchant isn't actually generating this. This is provided from the Instant Checkout experience. Apologies about that.
- 5:50
And from there, they start entering in their credentials. So they're gonna enter in some credit card details. It's just a test credit card number that they're gonna enter. And behind the scenes, that'll be tokenized with PayPal. So if you're kind of not familiar with payments, tokenization means where the user exchanges a real payment credential that's transactable, say, your credit card number- And instead, they exchange that for a token. That can then be passed around without increasing PCI scope and, you know, dangerous things happening. So that's what's gonna happen right
- 6:20
here behind the scenes, is a tokenization will occur, and that's... The merchant doesn't have to do that. This is, like, within the host, the host app is gonna do that tokenization, send it to PayPal Enterprise Payments, and then we give back the token to ChatGPT, and that's safe to pass around. So this is what's happening right now. Tokenization is occurring, and then it's gonna be sent to the merchant. The merchant receives that and says, "Okay, now I transact with that token securely." And now you see they've come back to the MCP app. This has
- 6:50
been updated. Their booking's been confirmed. And so you can see m- from a merchant's perspective, they have all control of what that UI looks like, and it's pretty seamless for the, the user. What are the integration points here? So, the first integration point is inside of that MCP app widget. So this, I'm showing you the real code for, um, for do this instant checkout with OpenAI. You need to have this JavaScript code that triggers that checkout experience. So that's provided within the context
- 7:20
of your MCP app. And then the next place where the merchant picks this up is they receive a call to their MCP server with this ch- complete checkout tool, and they get that token, and then they can proceed as usual with their processing of, you know, a typical PayPal Enterprise Payments token. So it's really pretty straightforward as far as that goes. Now, there's still obviously the work of creating an MCP app within that experience. Also, there's, um, links here
- 7:51
to the QR code if you wanna, like, follow and look at the docs for how you would set this up. And what's kinda happening behind the scenes here is these tokens are constrained in a number of ways. One of them is with the merchant, so that this is, can only be processed on a given merchant. It has a max amount of dollars that are applied. It has a currency. It also has an expiration, so you can't just use this forever. And all of those transactions, when processed, they get attributed to the source where they came from. So this would
- 8:21
show up within PayPal Enterprise Payments as a ChatGPT, um, transaction that occurred.
- 8:31
Um, so next, I'm gonna walk through what Google AI mode and how we're meeting merchants there. So, the flow looks a, a little bit different when you're processing transactions on Google AI mode. So, first of all, the user might be shopping in AI mode. They, you know, want to buy, you know, say, a pair of running shoes or something like that. Behind the scenes, using the Universal Commerce Protocol, the agent will create a session against that merchant for the user. So that kind of exists
- 9:01
as an entity belonging to the merchant, and, and it uses that. Then when the user says, "I now want to check out with this," the tokenization happens, but here, this is using Google Pay. So Google Pay would tokenize with PayPal Enterprise Payments, and so that's step three, and then give that token back to the merchant. And you kinda see this is actually a very similar model. Then at the completion step, they provide that to the merchant, and at step five, we do the charge. So the merchant comes along
- 9:31
and says, "Here's my token. I would like to process this transaction. Here's all the information about it." And the same sorts of things like this, again, settlement, refunds, chargeback risk, compliance, this all is just standard operating procedure as far as the merchant's perspective. But they receive this token from a different path. This came in through Google AI mode. One of the things to note here is in Google AI mode, the merchant doesn't create an MCP app.
- 10:01
They don't create an experience. Their integration with Google AI mode is more providing, "Here are my products. Here is my endpoints for receiving the payments, the complete checkout payment, um, and so forth." There is no, like, UI that you have to build. You have to stand up endpoints essentially to, to integrate with this. Um, so you can see here, one of them is specifi- specifying in your, um, well-known JSON file for
- 10:31
Universal Commerce Protocol, and you specify some things that tell us or tell Google Pay, "This is needs to be processed on Braintree or PayPal Enterprise Payments, and here's your merchant ID, and here's your client key," and that's safe to pass through in the public. Then Google will take that, and at the final end of it is you'll get a call to this endpoint from UCP checkout session with that session ID and a complete, and you then get to process that. And what you're receiving there is this, um,
- 11:02
token representing the credit card behind that Google Pay payment. So again, two main key integration points, um, as far as receiving those payments. The next one I'm gonna show you here is about MCP apps and just kind of opening up your mind about what are the other things that you could do with MCP apps. This one gives the merchant really full control over the whole experience, and we're gonna work in things that are not necessarily Google
- 11:31
or ChatGPT, but there's a lot of different, um, agents that already support MCP apps. So a couple of key pieces here. One is that there's the MCP app widget. So this will, in our example here, will show, like, a product card, and you'll get a checkout button. Then there'll be a handoff, um, that will open up the checkout into an external page. So then you can complete that there and then come back and get it automatically updated within your MCP app. So that gives you a lot
- 12:01
more control, but there is a little bit more friction that's in- introduced in this mode because you're not, you're not doing, like, the actual checkout inside of your agent. So let's, um, walk through this one. So here, we're gonna search for some things, uh, that we'd like to buy.
- 12:22
And this loads up an MCP app. And you can see this is using Claude. And this is a connector. So MCP apps show up as connectors or apps depending on, you know, the container. So here's... This is the MCP app. The merchant would design this. They add the things that the user is now is picking what they want. And when they click Checkout, this is now gonna pop up an external link, and you can tie these together with a session as a merchant. So that's what's happening here. This opens up that
- 12:52
session. They can then can complete things with any payment method that they want. You have complete control as a merchant over everything. But when you complete that, notice how this MCP app updates automatically. So we're using communication behind the scenes to allow us to know exactly that it was completed and the status of that order and everything. So that, again, just kinda demos for you what you can do with an MCP app and kinda what's on the table. And there's a lot of new things, um, coming along here. MCP apps has a new feature,
- 13:22
it's not supported in most of the major ones yet, that is called elicitation. And so you can do that maybe a little bit more seamlessly as far as requesting that external validation in an iFrame or something. So that's coming soon. Um, I wanted to show you what you could really do today, which is, you know, like this. This kinda gives you a little bit of an over- overview of, like, what are the different options, um, that we offer merchants today and kinda what are some of the trade-offs. So, like, if you wanna be in ChatGPT or you wanna be on Google,
- 13:52
um, there's options for you. Or if you want more control as a merchant over the whole experience, you also have, um, some options there too. And, um, yeah. So that's, um, that's the main thing that I wanted to share with you. Uh, there's a link here on this QR code if you wanna look at our docs, find out more about how to sign up and how to use that. And if you have any questions, um, I'd love to hear that. I don't know if we can maybe do questions here. Maybe just come talk to me
- 14:22
afterwards. We also have a booth over there in the back of the room, so I'm gonna be there for the next hour or so, and would love to talk to any of you who have any questions about, uh, what we offer. Thank you.