The ChatGPT Apps SDK is OpenAI's toolkit for building apps that run inside ChatGPT, released as an open standard built on the Model Context Protocol (MCP). When OpenAI introduced it, the company said monetization would include support for the Agentic Commerce Protocol, the open standard behind Instant Checkout in ChatGPT (OpenAI: apps in ChatGPT). OpenAI's developer site now groups this work under plugins for ChatGPT and Codex, built with "skills, MCP servers, and optional UI" (OpenAI Developers).
This article explains what the SDK is, how it relates to MCP, and how payments connect to apps in ChatGPT.
What Is the ChatGPT Apps SDK?
The ChatGPT Apps SDK is a framework for building interactive apps that users call from inside a ChatGPT conversation. An app exposes tools through an MCP server and can render its own interface in the chat. ChatGPT decides when to call the app based on the user's request.
Because it builds on MCP, an open protocol for connecting models to tools and data, the same server logic can serve other MCP clients (Model Context Protocol). OpenAI launched the SDK in preview alongside apps from partners, then expanded developer guidance for authentication, testing and publishing (OpenAI Developers).
How Do Payments Work in ChatGPT Apps?
Payments in ChatGPT connect through the Agentic Commerce Protocol (ACP), which powers Instant Checkout. OpenAI describes ACP as "an open standard for AI commerce" co-developed with Stripe, letting AI agents, people and businesses complete purchases together. Merchants integrate ACP so ChatGPT can complete a checkout on the user's behalf.
OpenAI published ACP documentation for merchants and developers (OpenAI Commerce docs; OpenAI: Buy it in ChatGPT). Developers on OpenAI's community forum have noted that Instant Checkout inside apps required an approval process at the time (OpenAI Community). See what is agentic commerce for the category.
ChatGPT Payments vs Onchain Agent Payments
ChatGPT's checkout runs on card and merchant rails through ACP, while onchain agent payments move stablecoins directly between wallets. The first suits consumer purchases from merchants. The second suits machine-to-machine payments such as paying per API call, where protocols like x402 let a server request payment over HTTP.
Dimension | ChatGPT Instant Checkout | Onchain agent payment | Source |
Standard | Agentic Commerce Protocol | x402 and wallet transactions | |
Payment method | Merchant payment rails | Stablecoins such as USDC | |
Who builds it | Merchants integrating ACP | Developers with agent wallets |
What Can Developers Build With the Apps SDK?
Developers can build apps that search catalogs, book services, show interactive results, and hand off to checkout, all inside ChatGPT. The common pattern is an MCP server that exposes a few well-defined tools plus an optional UI component. Apps that move money should keep authorization and limits on the server side rather than trusting the model's request.
For crypto use cases, the same MCP pattern can expose wallet tools to a model. Any tool that signs transactions needs limits the model cannot override; see AI agent spend controls and Gemini agent mode and payments.
How a ChatGPT App Works, Step by Step
A ChatGPT app works by exposing tools that ChatGPT can call during a conversation. Because the Apps SDK is built on the Model Context Protocol, the app's server describes its tools in a standard way, and ChatGPT decides when a user's request calls for one of them (OpenAI: apps in ChatGPT). A typical flow:
The user asks for something. For example, "find me a hotel near the conference venue for next Tuesday."
ChatGPT picks a tool. It matches the request to a tool the app exposes, such as a search tool.
The app's server runs the tool. It queries its own systems and returns structured results.
The app renders results. An optional UI component shows the results inside the chat, such as a list with images and prices.
The user refines or acts. They pick an option, and ChatGPT calls another tool, such as booking or adding to a cart.
Checkout, if any. For purchases, the flow hands off to a checkout path, such as Instant Checkout powered by the Agentic Commerce Protocol.
The important design point is that the server is in charge of what each tool actually does. ChatGPT proposes a call with arguments; the server decides whether to honor it.
Apps SDK, MCP and Plugins: How the Names Fit Together
The naming around OpenAI's developer tools has shifted, which confuses people searching for documentation. The pieces fit together like this:
Term | What it refers to |
Model Context Protocol (MCP) | An open protocol for connecting models to tools and data, used by several AI clients (Model Context Protocol) |
Apps SDK | OpenAI's toolkit for building apps inside ChatGPT, introduced as an open standard built on MCP |
Plugins for ChatGPT and Codex | How OpenAI's developer site now groups this work: plugins built with "skills, MCP servers, and optional UI" (OpenAI Developers) |
Agentic Commerce Protocol (ACP) | The open standard, co-developed with Stripe, behind Instant Checkout (OpenAI: Buy it in ChatGPT) |
Instant Checkout | The ChatGPT purchase flow that uses ACP |
Developers looking for current guidance should start from OpenAI's developer site, since older Apps SDK links now redirect to the plugins section.
How to Build a ChatGPT App: A Practical Outline
Building a ChatGPT app follows the shape of building any MCP server, plus an optional UI and OpenAI's publishing steps. An outline that keeps the work manageable:
Choose a narrow job. Pick one thing users will ask ChatGPT for that your service does well. Fewer, clearer tools work better than many vague ones.
Design the tools. Name each tool for what it does, describe its inputs precisely, and return structured results the model can reason about.
Build the MCP server. Implement the tools against your own APIs. Keep business rules on the server.
Add authentication. If the app acts on a user's account, connect it to your sign-in so every call maps to a real user with real permissions.
Add a UI component if it helps. Lists, maps and forms are easier to use as UI than as text.
Test with real prompts. Try the ways people actually phrase requests, including vague and adversarial ones.
Publish through OpenAI's process. Follow the current developer guidance for review and listing.
Keeping Money Movement Safe in ChatGPT Apps
Any app tool that moves money, books something paid, or changes an account needs controls on the server, because the model's request is only a request. Practical rules:
Authorize every call. Check that the signed-in user may perform this action, every time, on the server.
Confirm before charging. Show the user what will happen and the total, and require an explicit confirmation step for purchases.
Validate arguments. Do not trust amounts, item IDs or addresses from the model without checking them against your own data.
Cap and rate-limit. Limit how much and how often a tool can spend for a user.
Make actions idempotent. A repeated call should not create a second order or charge.
Log everything. Record the user, the tool call, the arguments and the outcome.
These rules apply whether payment runs through ACP, through your own checkout, or onchain.
Instant Checkout for Merchants
For merchants, Instant Checkout is a way to let ChatGPT complete purchases from their catalog. OpenAI describes ACP as an open standard that lets AI agents, people and businesses complete purchases together, and it publishes merchant documentation for integration (OpenAI: Buy it in ChatGPT; OpenAI Commerce docs). Merchants considering it should look at how product data is shared, how orders flow into existing fulfillment, how refunds and disputes work, and what approval steps apply. Developers on OpenAI's forum reported that Instant Checkout inside apps required approval at the time (OpenAI Community); check current requirements before planning around it.
Crypto and Stablecoin Apps Inside ChatGPT
Crypto apps inside ChatGPT follow the same MCP pattern: a server exposes tools, such as checking a balance, quoting a swap or preparing a payment. The difference is that onchain actions are final, so controls must work before a transaction is signed.
A sensible design keeps signing out of the model's reach. The app's tools can prepare a transaction and show it to the user, who signs with their own wallet. If the app must act without a person signing each time, it needs limits the model cannot change, such as allowed recipients, caps and minimum received. Programs that run inside one transaction can carry those checks: with Eco's Sauce SDK, the program reads onchain state, checks its conditions and reverts if they fail (Sauce docs). Sauce also ships an MCP server for coding agents, which shows the same protocol used on the developer side (Sauce for AI agents). For machine-to-machine payments over HTTP, see x402.
Common Mistakes When Building ChatGPT Apps
Teams building their first ChatGPT app tend to make the same few mistakes. Avoiding them saves rework during testing and review.
Too many tools: exposing every endpoint makes it harder for the model to pick the right one. Start with the few that match real requests.
Vague tool descriptions: the model chooses tools from their names and descriptions. Ambiguous wording leads to wrong calls.
Trusting the model's arguments: amounts, IDs and user details from a tool call must be validated on the server.
No confirmation for consequential actions: anything that charges, books or changes an account should show the user what will happen first.
Returning too much data: send the model what it needs to answer, not entire records that may contain private fields.
Testing only the happy path: real users phrase things in unexpected ways, and some will try to make the app misbehave.
Measuring a ChatGPT App After Launch
After launch, the useful measures are how often ChatGPT calls the app for the requests it is meant to serve, how often those calls succeed, and what users do next. Track tool calls by type, errors and refusals, completed actions such as bookings or purchases, and support contacts that mention the app. A tool that is called often but rarely leads to an action may need a clearer result format or a better description.
ChatGPT Apps vs Building Your Own Agent
A ChatGPT app puts your service where users already are, with ChatGPT handling the conversation and deciding when to call you. Building your own agent gives you full control over the model, the flow and the data, but you have to bring the users. Many teams do both: an MCP server that serves ChatGPT and other MCP clients, plus their own agent experience for customers who want more. Because MCP is a shared protocol, the server work carries over between them.
Frequently Asked Questions
Is the Apps SDK built on MCP?
Yes. OpenAI released it as an open standard built on the Model Context Protocol.
What is Instant Checkout?
A ChatGPT purchase flow powered by the Agentic Commerce Protocol, co-developed with Stripe.
Can ChatGPT apps take crypto payments?
OpenAI's ACP materials describe merchant checkout, not crypto payments.
What is the difference between the Apps SDK and MCP?
MCP is the open protocol for connecting models to tools. The Apps SDK is OpenAI's toolkit for building ChatGPT apps on top of it, with optional UI.
Where is the Apps SDK documentation now?
OpenAI's developer site groups it under plugins for ChatGPT and Codex; older Apps SDK links redirect there.
Do ChatGPT apps need user authentication?
Any app that acts on a user's account should authenticate the user and check permissions on the server for every call.
Can one MCP server serve ChatGPT and other AI clients?
Yes. Because the Apps SDK builds on the open Model Context Protocol, the same server logic can serve other MCP clients, with ChatGPT-specific UI added where it helps. Test each client separately, since clients differ in how they present tools.
Related Reading
Sources: OpenAI pages linked inline, accessed November 2026.