ChatGPT plugins
Last reviewed
May 30, 2026
Sources
No citations yet
Review status
Needs citations
Revision
v4 · 3,615 words
Improve this article
Add missing citations, update stale details, or suggest a clearer explanation.
Suggest edit
CtrlK
Last reviewed
May 30, 2026
Sources
No citations yet
Review status
Needs citations
Revision
v4 · 3,615 words
Add missing citations, update stale details, or suggest a clearer explanation.
ChatGPT plugins, GPTs, and the GPT Store are three successive extensibility layers that OpenAI bolted onto ChatGPT between 2023 and 2024 to let the chatbot reach external data, run code, and host third-party experiences. The plugin system launched in alpha on March 23, 2023, allowed GPT-4 to call APIs described by an OpenAPI specification, and was wound down on April 9, 2024.[1][2] Its successor, the "GPTs" framework (also called custom GPTs), was unveiled at OpenAI's first DevDay on November 6, 2023; GPTs are user-configurable variants of ChatGPT defined by natural-language instructions, uploaded knowledge files, and optional "actions" that call external APIs.[3][4] The GPT Store, a marketplace for sharing public GPTs, opened on January 10, 2024 with categories spanning writing, productivity, education, and DALL-E imagery.[5][6] In October 2025 OpenAI replaced the GPTs-and-actions model again with "apps in ChatGPT" and the Apps SDK, a framework built on the open Model Context Protocol that lets developers ship full interactive interfaces inside the chat.[16][17] This article is the shared disambiguation entry for the slugs chatgpt_plugin, chatgpt_plugins, chatgpt_store, and custom_gpt; deeper background on the underlying chatbot is at ChatGPT, while sibling marketplace and listing pages live at GPT Store and custom GPTs.
OpenAI announced ChatGPT plugins on March 23, 2023, describing them as "tools designed specifically for language models with safety as a core principle" that help ChatGPT access up-to-date information, run computations, and use third-party services.[1] Access opened in alpha to selected developers and to ChatGPT Plus subscribers on a waitlist, with priority given to a small initial cohort before any wider or API-based rollout.[1][7] The feature graduated from a closed alpha to an opt-in beta for all Plus subscribers around May 12, 2023, when the plugin store contained roughly 70 third-party plugins and a user could enable the browsing and plugin betas from the settings panel.[7][18]
Two plugins were hosted by OpenAI itself. The first was a web-browsing plugin built on the Bing search API; it let ChatGPT retrieve content from the open web during a conversation and cite the URLs it had consulted, extending the model past its September 2021 training cutoff.[7] The second was a sandboxed Python "code interpreter" that gave the chatbot disk space for file uploads and downloads and could run scripts for data analysis, plotting, and format conversion.[1][7] OpenAI quietly renamed Code Interpreter to "Advanced Data Analysis" in late August 2023, alongside the launch of ChatGPT Enterprise, although the underlying capability was unchanged.[19] OpenAI also open-sourced a "retrieval" plugin that any developer could self-host to index private files, emails, and documentation for semantic search; the repository shipped connectors for several vector databases, including Pinecone, Weaviate, and others, and is a common reference implementation of retrieval-augmented generation.[1][20]
The third-party plugin set went live with launch partners including Expedia, Instacart, Kayak, Klarna, OpenTable, Slack, Wolfram, Shopify, and Zapier.[1][7] Each partner published a JSON manifest at the path /.well-known/ai-plugin.json together with an OpenAPI specification of its endpoints; ChatGPT consumed those files at install time, converted the API surface into a tool description, and decided when to invoke specific endpoints based on the user's prompt.[8] By the time of the deprecation announcement, more than 1,000 plugins had been published.[2]
A plugin was, in practice, three things glued together: an existing web service exposed as a REST API, a manifest file, and an OpenAPI schema describing that API.[8][21] When a user installed a plugin for a domain such as example.com, ChatGPT fetched the manifest from https://example.com/.well-known/ai-plugin.json. The manifest declared metadata and, crucially, two model-facing fields. name_for_model set the namespace ChatGPT used to refer to the plugin internally, and description_for_model acted as a short prompt that told the model what the plugin was for and when to call it.[21] OpenAI supported only one manifest schema version (v1) and only OpenAPI as the specification format. At runtime, ChatGPT combined the manifest and the schema into a synthetic tool description, inserted it into the model's context, and let the model emit calls to the documented endpoints, then fed the responses back into the conversation.[8][21]
The table below summarizes the components a developer had to ship.
| Component | Location or format | Purpose |
|---|---|---|
| API backend | Developer-hosted web service | Performs the actual work and returns JSON to ChatGPT |
| Manifest | /.well-known/ai-plugin.json | Declares the plugin name, human and model descriptions, auth method, logo, and contact info |
| OpenAPI schema | JSON or YAML, referenced by the manifest | Documents the available endpoints, parameters, and responses |
| Authentication | None, service-level, user-level, or OAuth | Controls how ChatGPT proves it may call the API on the user's behalf |
This pattern made the plugin format unusually portable. Because it relied on the open OpenAPI standard rather than a bespoke OpenAI interface, the same manifest-and-schema approach was reused almost verbatim when OpenAI introduced GPT actions, which is one reason the migration path from plugins to GPTs was mostly a packaging change for developers.[11][21]
Plugin support never escaped beta. OpenAI announced on February 23, 2024 that it would wind down the plugins beta, telling users that GPTs were a better way to reach ChatGPT.[2][9] Under the published schedule, users could no longer install new plugins or open new conversations that used a plugin after March 19, 2024, and existing plugin conversations stopped working on April 9, 2024.[2][9] OpenAI directed plugin users to the GPT Store and pointed plugin builders at the GPT "actions" system that had subsumed the manifest and OpenAPI pattern. Third-party providers followed suit: Zapier, for example, published its own notice sunsetting the Zapier ChatGPT plugin and steering users toward its GPT integration.[2][9]
GPTs were announced by Sam Altman during the opening keynote of OpenAI's first developer conference, DevDay, on November 6, 2023.[3][4] OpenAI described them as "tailored versions of ChatGPT" that "combine instructions, extra knowledge, and any combination of skills" so anyone, including users without coding experience, could build a domain-specific assistant.[3][4]
A GPT is defined by a handful of editable elements.[3][4][10] Instructions are a free-form natural-language prompt that sets the assistant's persona, tone, and behavior. Knowledge is a set of files (originally up to 20 per GPT, with size limits per file) that the GPT can retrieve from at inference time, covering common document, spreadsheet, image, text, and code formats.[10] Conversation starters are suggested opening prompts shown to first-time users. Capabilities can be toggled on or off, including web browsing, the DALL-E image generator, and Python data analysis (Code Interpreter). Actions, the most powerful element, let a GPT call external REST APIs via an OpenAPI schema, replacing the function performed by the older plugin manifest.[10][11]
OpenAI's GPT Builder, a conversational tool inside ChatGPT, asks the creator what they want the GPT to do and drafts the instructions, name, and icon automatically; creators can then switch to a "configure" view to edit fields directly.[10] By default a GPT is private to its author, but the author can share a link with collaborators, publish it within an Enterprise or Team workspace, or list it publicly in the GPT Store.[4][5] The initial release of GPTs ran on GPT-4 Turbo, the 128,000-token-context model that OpenAI also introduced at DevDay; later iterations were powered by GPT-4o, GPT-4.5, and GPT-5 as those models shipped.[4]
OpenAI reported that users created more than three million GPTs in the two months after the feature opened to subscribers, although only a small fraction were ever submitted to the public store.[5][12]
Actions are the part of a GPT that connects it to the outside world, and they are the direct technical heir of the plugin manifest. A builder defines an action by supplying an OpenAPI schema (in JSON or YAML) describing one or more API endpoints, then choosing an authentication scheme in the GPT editor: none, an API key, or OAuth.[11][22] When the action needs OAuth, the editor collects the client ID, client secret, authorization URL, token URL, and scopes, and ChatGPT manages the token exchange so the GPT can call the API on the signed-in user's behalf.[22] The differences from plugins are mostly about ownership and packaging rather than mechanism.
| Aspect | ChatGPT plugins (2023) | GPT actions (2023 onward) |
|---|---|---|
| Unit the user picks | A standalone plugin, toggled per conversation | A whole GPT that may include several actions |
| Discovery | The in-app plugin store | The GPT Store and shared links |
| Definition | ai-plugin.json manifest plus OpenAPI schema | OpenAPI schema configured inside the GPT editor |
| Who controls the experience | The third-party service | The GPT builder, who also writes instructions and uploads knowledge |
| Authentication | None, service-level, user-level, or OAuth | None, API key, or OAuth |
| Concurrent integrations | A small fixed number of enabled plugins | Multiple actions bundled into one GPT |
Because the schema format barely changed, many plugin developers migrated by lifting their existing OpenAPI specification into a GPT action and writing a short set of instructions around it.[11][21]
The GPT Store opened on January 10, 2024, two months after the GPTs framework was announced and a few weeks later than the late-November target Altman had floated on stage.[5][6] It is reached through a dedicated tab inside ChatGPT on the web and requires a paid subscription, originally ChatGPT Plus, ChatGPT Team (launched the same day), or ChatGPT Enterprise.[5][6] At launch OpenAI said users had already created more than three million GPTs since November.[5][12]
The store organizes public GPTs into curated categories such as Writing, Productivity, Research and Analysis, Programming, Education, Lifestyle, and DALL-E, alongside a "trending" leaderboard and editorial "top picks."[5][6] Launch-day featured GPTs included a trail recommender from AllTrails, a code tutor from Khan Academy, a content designer from Canva, and an academic search GPT from Consensus.[5][6] To list a GPT publicly, a builder must verify their profile and pass a mixed human-and-automated review against OpenAI's usage policies.[5][6]
A revenue-sharing program for builders was announced alongside the store and entered a pilot in the first quarter of 2024, initially restricted to a small group of U.S.-based builders whose GPTs had attracted significant engagement. Payouts were tied to "user engagement" with their GPTs rather than per-call usage or subscriptions, although OpenAI signaled that subscription-based GPTs might follow.[5][13] The program stayed narrow: builders generally had to be U.S.-based, verified, and clearing a sustained activity bar (reported around 25 conversations per week) to qualify for any payout, and most public GPTs earned nothing.[13][23] By February 2024, third-party trackers were observing roughly 1,500 new public GPTs added to the store per day, and by mid-2024 the public catalog had grown to around 159,000 listings out of roughly three million total GPTs created by users.[12]
Plugins drew heavy press attention at launch, often framed as ChatGPT getting "eyes and ears" or its own app store. In practice usage stayed concentrated among power users, and OpenAI later said adoption never reached the scale it expected for a feature available to every Plus subscriber, which it gave as a reason for the pivot to GPTs.[2] Common complaints during the beta were practical: a user could enable only a few plugins at once, the model did not always pick the right plugin, and many integrations were thin wrappers that were slow or unreliable.[7][8]
GPTs broadened who could build an assistant, but they inherited and added limitations of their own. A GPT is bound to OpenAI's models and to ChatGPT as a host, so a public GPT is not a durable, portable product the way a standalone app would be. Builders also discovered that anything uploaded to a public GPT, including knowledge files and the system instructions, was effectively exposed to determined users. Researchers at Northwestern University tested more than 200 user-designed GPTs and reported a 97.2 percent success rate at extracting the hidden system prompt and a 100 percent success rate at exfiltrating uploaded knowledge files using ordinary prompt-injection techniques.[24][25] OpenAI added settings to limit, for instance, whether a GPT's code or files could be downloaded, but the underlying problem (that instructions and retrieved content share one text channel with the user) is structural, not a single bug.[24]
Tool use turns a chatbot into something closer to an agent, and that raised the stakes for security. The dominant class of risk across plugins, actions, and apps is prompt injection: untrusted text, whether in a fetched web page, an API response, or an uploaded document, can contain instructions that the model follows as if they came from the user. Because plugins and actions can read private data and trigger real operations through authenticated APIs, a successful injection can do more than produce bad text; it can leak credentials or perform unintended actions on a connected service.[25][26]
Security researchers documented concrete instances. Studies of third-party chatbot plugins deployed on thousands of websites found that many failed to separate trusted from untrusted content or to protect the integrity of conversation history, which let attackers forge context and steer the assistant.[25] Reviews of ChatGPT plugins also flagged OAuth and account-takeover risks, where flaws in a plugin's authorization flow could expose a user's account on the connected service.[26] These findings did not stop the rollout, but they shaped how OpenAI staged later releases. The successor app platform runs third-party interface code in a sandboxed iframe and routes data access through reviewed Model Context Protocol servers, and OpenAI gated it behind a review process before opening public submission.[16][17]
At DevDay on October 6, 2025, OpenAI introduced "apps in ChatGPT" and a preview of the Apps SDK, the next extensibility layer after GPTs and actions.[16][17] Where a plugin or an action could only call an API and return text, an app can render its own interactive interface inside the conversation: a ChatGPT app is a web component (HTML, CSS, and JavaScript, optionally built with a framework such as React) that runs in a sandboxed iframe and appears as an interactive card or panel in the chat thread.[16][27] The Apps SDK is built on the Model Context Protocol, the open standard Anthropic published in late 2024 for connecting assistants to tools and data, and OpenAI extended MCP so a developer can ship both the app's logic and its user interface from a single MCP server. OpenAI released the SDK as open source so apps could in principle run on any host that adopts the standard.[16][27]
Launch partners demonstrated on stage included Booking.com, Canva, Coursera, Expedia, Figma, Spotify, and Zillow, with examples such as asking Spotify to build a playlist or turning an outline into a Canva deck without leaving the chat.[16][17] Altman framed the announcement against ChatGPT's reach, saying the product had passed 800 million weekly active users and that roughly four million developers had built with OpenAI.[17][28] Apps were initially available in preview to ChatGPT Business, Enterprise, and Edu customers, with the SDK open to developers for building immediately.[16][27]
On December 17, 2025, OpenAI opened app submissions to all developers and launched an app directory inside ChatGPT, reachable from the tools menu or at chatgpt.com/apps, where users can browse featured apps or search the catalog.[27][29] Developers submit apps, including their MCP connectivity details and directory metadata, through the OpenAI developer platform and track review status there; approved apps began rolling out gradually in early 2026.[27][29]
The progression from plugins to GPTs to apps is as much an architectural story as a product one. Each layer moved control and capability in a consistent direction.
| Era | Launch | Unit of distribution | What it could do | Status |
|---|---|---|---|---|
| ChatGPT plugins | March 2023 | A plugin enabled per conversation | Call an external API described by OpenAPI; OpenAI-hosted browsing, code interpreter, and retrieval | Discontinued April 9, 2024 |
| GPTs and the GPT Store | November 2023; store January 2024 | A configurable GPT, shareable or listed | Bundle instructions, knowledge files, model capabilities, and OpenAPI-based actions | Active, but superseded as the headline platform |
| Apps in ChatGPT (Apps SDK) | October 2025; directory December 2025 | An app discoverable in the app directory | Render an interactive UI in a sandboxed iframe via an MCP server, plus tool calls | Active, in rollout |
Under the plugin model, third-party services owned the user experience: a developer hosted an ai-plugin.json manifest and an OpenAPI schema, and ChatGPT enabled or disabled the whole plugin per conversation. Discovery happened through a plugin store inside ChatGPT, and a user could load only a handful of plugins at once.[1][7][8]
Under the GPTs model, the builder owns a complete chatbot persona, with the API connection demoted to one component among several. A GPT bundles instructions, retrieval files, model capabilities, and zero or more actions that wrap an OpenAPI specification almost identical to the plugin format.[10][11] The user does not enable an API; the user picks a GPT, and the GPT decides when to call out. This change also shifted distribution: instead of a flat list of plugins gated by toggles, the GPT Store is closer to a consumer app marketplace with categories, leaderboards, and a builder revenue pool.[5][6][13]
Under the apps model, the unit becomes a sandboxed mini-application with its own interface, and the connective tissue is an open protocol rather than an OpenAI-specific manifest. The same architectural arc, moving from vendor-specific plugin manifests toward a model-agnostic protocol for tool use, played out across the industry. Anthropic introduced the Model Context Protocol in November 2024 as an open JSON-RPC standard for connecting AI assistants to external data sources and tools; OpenAI adopted MCP across its products in March 2025, after which ChatGPT could speak to third-party MCP servers without each integration needing a GPT wrapper, and then built the Apps SDK directly on top of MCP.[14][15][16]
For all that the plugin beta was short-lived, it was an early, public demonstration of an idea that now underpins the AI agent ecosystem: a large language model does not have to answer from its weights alone; it can be given tools, decide when to use them, and act on the results. The plugin format's reliance on OpenAPI, rather than a closed interface, set an expectation that tool use should be describable in an open, machine-readable way. That lineage runs straight through GPT actions, OpenAI's function calling in the API, the Assistants API, and ultimately the cross-vendor Model Context Protocol. Viewed from 2026, ChatGPT plugins read less like a failed feature than like a first draft of the tool-use and agent platforms that followed.