ChatGPT App vs Custom GPT: What Is the Difference? (September 2026)

Custom GPTs and ChatGPT Apps both let people work inside ChatGPT, but they have different building blocks. The choice has also changed: OpenAI now plans to retire Custom GPTs, so a new project should account for the plugin path from the start.

TL;DR: Custom GPTs are configured assistants. ChatGPT Apps pair MCP tools with interactive UI. OpenAI plans to retire Custom GPTs on December 11, 2026, with limited workspace exceptions. For new work, use a plugin skill for instructions and files, an MCP server for live tools, and UI when users need it.

What Changed in September 2026

OpenAI’s Custom GPT retirement FAQ lists December 11, 2026 as the planned retirement date. Some Enterprise workspaces with an approved deferral have until February 11, 2027. Follow the notice for your account or workspace, because migration access and permissions vary. OpenAI’s GPT guide also says new GPT creation and publishing are unavailable on personal Free, Go, Plus, and Pro accounts. Managed workspaces may still allow them under their own settings.

That does not make an existing GPT unusable today. It means the old advice to start a new Custom GPT for every text-first workflow has a short shelf life. Plugins are the replacement path. A plugin can carry skills with instructions and reference files, an MCP server with live tools, or both. OpenAI’s plugin architecture guide says custom UI is optional, so a text-first workflow does not need an iframe or a custom server just to keep its instructions.

The Short Version

The simplest way to choose is to look at the user’s output.

An existing Custom GPT can still suit a text-first workflow while it remains available. That might be a support assistant that knows your docs, a helper with a specific tone, or a GPT that calls an API and summarizes the result. For a new version of that workflow, plan a plugin skill and reference files instead.

Use a ChatGPT App when the ideal result is a working interface. That might be a dashboard, a kanban board, a pricing configurator, a document editor, a compliance review queue, a booking flow, or a data table with filters. The model still matters, but the user needs UI, not just a message.

That distinction matters because the implementation paths differ. A Custom GPT was configured in ChatGPT and can migrate to a plugin. A ChatGPT App uses an MCP server with tools and UI resources. A plugin does not require custom UI.

What Custom GPTs Are

Custom GPTs let you configure a version of ChatGPT for a specific purpose without building a full app. Where creation remains available, the GPT builder lets you write instructions, add conversation starters, upload knowledge files, enable built-in capabilities, and connect external APIs through Actions. A GPT can use apps or actions, but not both at once, according to OpenAI’s GPT guide.

The end product is still a chat assistant. It can answer in a certain style, use the files you provided, call an action, and return a response. That is useful when the user wants a conversation that behaves consistently.

Existing Custom GPTs still work well for:

• Internal assistants tuned to company docs, policies, or terminology.
• Customer support bots where the answer can stay in text.
• Reusable prompts for research, planning, writing, or analysis.
• Lightweight API workflows where the API result can be summarized.
• Teams that need a quick prototype without a frontend or backend project.

The tradeoff is that a GPT does not give you its own application surface. You cannot ship a React component inside it, keep a sortable table on screen, open a full-screen editor, or sync user clicks back into a typed app state model. For those jobs, use an MCP-backed ChatGPT App.

What ChatGPT Apps Are

A ChatGPT App is an MCP App that runs inside ChatGPT. Your server exposes MCP tools and UI resources. ChatGPT calls a tool, receives structured data, and renders the linked UI resource in a sandboxed iframe inside the conversation.

That UI resource can be a normal web app. It can render charts, forms, tables, maps, media controls, review screens, and multi-step workflows. The app can call server tools, send follow-up messages, update model-visible context, and react to host state through the MCP Apps bridge.

Current OpenAI guidance says new ChatGPT App UI should start with the MCP Apps standard:

1. Link tools to UI with _meta.ui.resourceUri.
2. Use the standard ui/* JSON-RPC bridge over postMessage.
3. Add ChatGPT-specific window.openai APIs only when you need ChatGPT-only features.

For a new UI, follow OpenAI’s ChatGPT UI guide: build on the shared MCP Apps bridge, then add ChatGPT-specific features only where needed. Public distribution uses a plugin with a remote MCP server. The standard fields give the UI a path to other MCP Apps-compatible hosts.

Side by Side

	Custom GPT	ChatGPT App
Requires code?	No for most use cases	Yes
Primary output	Chat response	Interactive iframe UI plus tool results
Setup surface	GPT builder	MCP server, tools, resources, UI bundle
New personal-account creation	Unavailable on Free, Go, Plus, and Pro	Build through the plugin and MCP path where access permits
Planned retirement	December 11, 2026, subject to account notices and approved deferrals	No Custom GPT retirement date applies
Data shape	Instructions, knowledge, action responses	structuredContent, _meta, app state
API calls	GPT Actions	MCP tools
UI control	ChatGPT-rendered text and markdown	Your HTML, CSS, and JavaScript
Portability	ChatGPT only	Portable when built on MCP Apps APIs
Testing need	Prompt and action tests	Tool, UI, bridge, display mode, and host tests
Best use case	Knowledge assistant	Product-like workflow inside chat

An existing Custom GPT changes how ChatGPT behaves. A ChatGPT App gives ChatGPT a product surface to call and render. A plugin skill can preserve an instruction-led workflow without adding an app UI.

The MCP Apps Difference

The broader MCP Apps ecosystem is the main reason this comparison has changed since early ChatGPT App docs. ChatGPT Apps are no longer best understood as a ChatGPT-only iframe feature. They are ChatGPT’s implementation of the MCP Apps pattern.

MCP Apps split the system into three parts:

• The MCP server declares tools and UI resources.
• The host decides when to call tools and where to render UI.
• The view runs in a sandboxed iframe and talks to the host through the bridge.

This keeps your app code from reaching into the host page. The iframe cannot read ChatGPT’s DOM, cookies, or local storage. The bridge is the narrow channel for tool input, tool output, app state, messages, and host requests.

The practical benefit is portability. A Custom GPT only exists in ChatGPT. A ChatGPT App built around MCP Apps standard fields can share more code across compatible hosts because the server, resource metadata, and bridge model are standard. You may still need host-specific polish, but your core app does not have to be rewritten around one private global.

What the Model Sees

Custom GPTs are easy to reason about because the model sees the conversation, the GPT instructions, any selected knowledge, and action results. The output is a response.

ChatGPT Apps have more data lanes:

• content is for model-visible text or media.
• structuredContent is typed data the model can reason over.
• _meta is for app-only data the UI needs but the model should not read.
• App state is for user interactions that should become model context.

That separation is one of the strongest reasons to build an app. A sales dashboard can show a large table in the iframe while exposing only the summary the model needs. A claims review screen can keep sensitive UI-only metadata out of model context. An editor can sync the user’s selected paragraph or approval status back to the model without dumping the full DOM into chat.

Custom GPTs do not give you that same set of lanes. Their simpler setup can still help with an existing text-first task, while the plugin path is the one to plan for its replacement.

Where an Existing Custom GPT Still Fits

If your team already has a Custom GPT for instructions and knowledge, keep using it while it remains available and prepare its replacement. A support GPT might answer from uploaded docs; a finance GPT might explain internal policy. Those examples need a reusable skill and reference files in the new plugin model, not necessarily a custom app UI.

For an instruction-only replacement, you do not need to deploy an MCP server or design UI. OpenAI’s plugin architecture supports skills without a server. If your GPT uses Actions, plan integration work separately because the migration FAQ says custom actions do not transfer automatically.

The simplest replacement candidates share these traits:

• The user wants an answer, draft, summary, or recommendation.
• The output does not need a persistent interactive surface.
• The team wants to configure behavior without owning app infrastructure.

If those are true, start with a plugin skill and reference files. Add an MCP server only when the workflow needs live data or actions.

When ChatGPT Apps Win

Build a ChatGPT App when the user needs to work with state, not just read an answer. The moment the user needs to sort records, pick options, review changes, compare items, fill a form, adjust a chart, inspect a file, or approve a write action, UI starts to earn its keep.

ChatGPT Apps also make more sense when the app needs strict contracts. You can define tool schemas, output schemas, resource metadata, CSP rules, display modes, and app-only tools. That gives you a better test surface than a prompt-only workflow.

Good ChatGPT App candidates include:

• Approval queues where the model prepares work and the user confirms it.
• Dashboards where the user filters or drills into structured data.
• Editors where the model proposes changes and the user revises them.
• Configuration flows where each step depends on prior state.
• Search and browse tools where the user needs to compare many results.
• Internal tools that should work in ChatGPT and other MCP Apps-compatible hosts.

For these workflows, a text response usually forces the user to copy data into another tool. A ChatGPT App keeps the workflow in the conversation.

Developer Mode, Distribution, and Testing

For live ChatGPT testing, expose your MCP server over HTTPS. Developer mode is required to add a custom app. Enable it from the user component in the bottom-left corner under Settings > Security and login > Developer mode. Then open Plugins from the ChatGPT sidebar, select an existing development app, or use the + button to add one. Complete the app form if needed, then run your test prompts in a new chat.

For public distribution, OpenAI’s plugin submission guide uses the OpenAI Platform plugin portal. A plugin can contain skills, a remote MCP server, or both, and the UI is optional. For an MCP-backed app, choose With MCP and submit a stable public HTTPS endpoint, verified publisher identity, listing and policy details, tool annotations, test cases, and review access when needed. Review precedes publication.

That is a real software lifecycle. You should test more than prompts:

• Unit test tool handlers and schema validation.
• Test structuredContent against the declared output shape.
• Render the iframe in each display mode your app requests.
• Check light mode, dark mode, mobile widths, and state restore.
• Run golden prompts to confirm the model chooses the right tools.
• Test auth, permission prompts, and write-action confirmation flows.

This is where sunpeak fits. sunpeak is an open-source MCP App framework, ChatGPT App framework, testing framework, and inspector. A new project can run npx sunpeak new and pnpm dev to start a local inspector and MCP server. For an existing MCP server, npx sunpeak inspect --server <url> lets you inspect tools and app UI without moving the backend into a new project.

How to Move an Existing Custom GPT

The retirement and migration FAQ says the built-in migration uses the GPT’s latest published version. Its instructions become a skill, knowledge files become reference files, and connected apps are added to the plugin. Draft edits, existing conversations, sharing settings, and custom actions do not transfer. The original GPT remains usable until retirement but becomes read-only after migration.

Before switching users over:

1. Publish any essential edits to the GPT and save a few prompts that show its normal work.
2. Migrate when the option appears in the account or workspace where the GPT was created.
3. Review the skill instructions and reference files, then compare familiar prompts and one difficult case.
4. Rebuild or replace custom actions, test their permissions, and confirm intended users can access the plugin. Migration does not share it for you.

If the GPT only used instructions and files, a skill may be enough. If it depended on an API action, use an available app or an MCP server where access allows. Add a ChatGPT App UI only when the workflow benefits from a view people can inspect or control. See Submit a ChatGPT App as a Plugin for the distribution path.

Which Path Should You Build Now?

Ask these questions in order:

1. Is the user happy with a text or markdown answer guided by instructions and files? Start with a plugin skill.
2. Does the workflow need live data or actions in another service? Add an MCP server or an available app connection.
3. Does the user need to click, edit, filter, approve, browse, or submit in a dedicated view? Add MCP App UI.

An existing Custom GPT can continue during the transition, subject to its account’s notice. For new work, choose the smallest plugin shape that handles the job. A skill covers repeatable guidance, an MCP server handles live tools, and a ChatGPT App adds UI when people need it. That is a more useful decision than treating every text workflow as a future iframe project.

Building a ChatGPT App

If you have decided the app path is right, start with the MCP Apps architecture instead of a ChatGPT-only wrapper. Define one narrow tool, return predictable structuredContent, attach a UI resource with _meta.ui.resourceUri, and render the smallest useful interface. Add ChatGPT-specific APIs later only where they improve the ChatGPT experience.

With sunpeak, the fastest path is:

npx sunpeak new chatgpt-app
cd chatgpt-app
pnpm dev

That starts a local inspector at localhost:3000 and an MCP server at localhost:8000. You can iterate on the UI, switch host modes, test tool results, and add Playwright coverage before connecting the app to ChatGPT developer mode.

For an existing server:

npx sunpeak inspect --server http://localhost:8000/mcp

That gives you the same inspection loop without changing your backend. Build the app like a real web product, because that is what a ChatGPT App becomes once users depend on it.