+170 XP

ChatGPT · What custom GPTs are and the GPT store

A custom GPT is a configured version of ChatGPT that you set up once for a job you do over and over. You then reuse it (or publish it) without rebuilding the setup every time. Think of it as ChatGPT plus a fixed system prompt, a set of files, optional tool connections, and a name, all bundled into a shareable unit that lives in the GPT Store.

You already know how to write a good prompt. A custom GPT is what you reach for when one good prompt is not enough: when the instructions are long, when the same reference files matter every time, or when other people need to run the job without seeing the machinery.

Anatomy of a custom GPT

Open the builder at chatgpt.com/gpts/editor. You need Plus, Pro, Business (formerly Team), Enterprise, or Edu. A custom GPT is made of a few parts:

  • Instructions: the persistent system prompt. This is the behavior contract, not a one-off request.
  • Knowledge: files you upload (PDFs, docs, spreadsheets) that the GPT can read on every conversation.
  • Capabilities: toggles for Web Search, Canvas, Code Interpreter & Data Analysis, and image generation.
  • Recommended model: the model the GPT should use by default. Users on plans with model choice can still switch.
  • Actions: connections to external APIs so the GPT can fetch or send real data.
  • Conversation starters: example prompts shown on the launch screen.

The builder has a conversational setup mode, but for anything serious you should edit the Configure tab directly. The conversational mode is convenient and vague. The Configure tab is where you control exactly what the instructions say.

The concrete example: a brand voice writer

Say your company has a tone guide: warm, direct, no hype, British spelling, never use the word "leverage." Marketing, sales, and support all need to write in that voice. Pasting the guide into every chat is brittle and inconsistent.

Build an "Acme Brand Voice Writer" GPT instead.

Instructions (the contract):

text
You are Acme's brand voice writer. Rewrite or draft copy in Acme's
voice: warm, direct, plain. No hype words (leverage, synergy,
game-changing, unlock). British spelling. Sentences under 25 words
where possible. Active voice.

When the user gives raw copy, return: (1) the rewritten version,
(2) a one-line note on what you changed and why.

If the request conflicts with the tone guide in your knowledge files,
follow the tone guide and say so briefly.

Knowledge: upload acme-tone-guide.pdf and a dos-and-donts.md. Now every conversation starts with the full guide loaded, no pasting.

Capabilities: turn Web Search off (you do not want it inventing facts about products), and keep Canvas on so writers can edit drafts side by side.

Conversation starters: "Rewrite this homepage hero," "Draft a launch email," "Tighten this paragraph."

Now anyone on the team opens one GPT and gets consistent output. That consistency is the whole point: the instructions and the tone guide do not drift between people or sessions.

When a custom GPT beats a saved prompt

You can save prompts as text snippets, and ChatGPT Projects let you set custom instructions plus shared files scoped to a workspace. So the choice comes down to a few signals.

Reach for a custom GPT when:

  • Multiple people need the same behavior. A saved prompt lives on your machine; a GPT is shareable by link or published to your workspace.
  • The instructions are long and stable. A 600-word behavior contract belongs in a config, not retyped.
  • You need bundled knowledge files that apply to every conversation, not just one.
  • You need Actions. Only custom GPTs (and the API) can call your own custom endpoints this way.
  • You want a clean launch surface, with a name, an icon, and starter prompts for non-technical users.

A saved prompt or Project is enough when:

  • It is just you, and the prompt is short.
  • The context changes every time, so a fixed instruction set would only get in the way.
  • You are iterating fast and do not want to maintain a published artifact.

Rough rule: Projects are for *your* recurring work with shared files; custom GPTs are for *packaging a repeatable job for others* (or for a clean, named tool you return to). They overlap, and that is fine.

Build a Custom GPT from Scratch

Watch on YouTube

Actions: where custom GPTs get powerful

A GPT Action lets your custom GPT call an external API during a conversation. This is the same idea as function calling on the API, but configured through an OpenAPI schema in the builder instead of code.

Extend the brand voice writer. Suppose approved product facts live in an internal endpoint. You give the GPT an Action so it can fetch real specs instead of guessing. You define the action with an OpenAPI schema like this:

yaml
openapi: 3.1.0
info:
  title: Acme Product Facts
  version: "1.0"
servers:
  - url: https://api.acme.com
paths:
  /products/{sku}:
    get:
      operationId: getProductFacts
      summary: Get approved facts for a product SKU
      parameters:
        - name: sku
          in: path
          required: true
          schema: { type: string }
      responses:
        "200":
          description: Product facts
          content:
            application/json:
              schema:
                type: object
                properties:
                  name: { type: string }
                  claims: { type: array, items: { type: string } }

Paste that into the Action editor and add an auth method (API key or OAuth). The GPT can now call getProductFacts when a user asks it to write copy for a SKU. The model decides when to call it based on your instructions and the action's `summary`. See Actions in the docs for auth and schema details.

Two things to internalize:

  • Write clear operationId and summary fields. The model uses them to decide whether and how to call the action. Vague summaries cause missed or wrong calls.
  • Actions run with the permissions you configure. If the GPT is published, treat the action as a public door into that API.

Actions vs apps (formerly connectors)

Do not confuse Actions with apps, which OpenAI previously called connectors. Apps link ChatGPT to services like Google Drive, SharePoint, or GitHub so you can pull in their content inside chats and Projects. Actions are custom API calls you wire into a specific GPT. Use apps to bring in your documents from supported services. Use Actions to hit your own endpoint or trigger a custom operation.

Publishing and the GPT store

The GPT Store is where published custom GPTs are discovered. When you finish building, you choose visibility:

  • Only me: private.
  • Anyone with the link: shareable, unlisted.
  • Workspace (Business/Enterprise/Edu): visible to your org only.
  • Public: listed in the Store for everyone.

To publish publicly you need a verified builder profile (a name or a verified domain). The Store organizes GPTs into categories and surfaces popular ones. OpenAI has run a revenue program for US builders based on usage; treat specifics as subject to change and check current terms rather than assuming a fixed rate. The official overview is at help.openai.com.

One sharp limitation to remember: **a public GPT runs on the *user's* ChatGPT account and plan**. Free users can use GPTs but get tighter limits and may get different model access than you had while building, even if you set a recommended model. Test as a non-builder before you ship.

Knowledge check

1. What best describes the purpose of a custom GPT compared to writing a single good prompt?

2. In a custom GPT, what role do the 'Instructions' play?

3. Why does the lesson recommend editing the 'Configure' tab directly rather than relying on the conversational setup mode?

MULTIPLE CHOICE

4. Select ALL situations where building a custom GPT is a better choice than writing a single prompt each time.

Select all the correct answers.

MULTIPLE CHOICE

5. Select ALL of the following that are genuine parts (components) of a custom GPT as described in the lesson.

Select all the correct answers.

Custom GPTs vs the API: knowing which side you are on

This is the distinction that separates people who *use* ChatGPT from people who *build products* on OpenAI.

A custom GPT lives inside ChatGPT. It is bounded by the ChatGPT app: the user must have a ChatGPT account, the UI is fixed, and you configure it with instructions, files, and Actions. No code required.

The OpenAI API (the Responses API and the older Chat Completions API) is for embedding the model in *your own* application. You write code, you control the interface, you pay per token, and you can use function calling, structured outputs, the Agents SDK, and more.

The same brand voice job, on the API side, looks like this:

python
from openai import OpenAI

client = OpenAI()

TONE_GUIDE = open("acme-tone-guide.md").read()

resp = client.responses.create(
    model="gpt-5",
    instructions=f"Rewrite copy in Acme's brand voice.\n\n{TONE_GUIDE}",
    input="Rewrite: 'We leverage cutting-edge synergy to unlock value.'",
)

print(resp.output_text)

Same instructions, same tone guide. The difference is *where it runs*: inside ChatGPT for your team, versus inside your own app for your customers. Check the models page for the current model names and prices before you pick one.

How to choose:

  • Custom GPT when the audience is ChatGPT users, you want zero infrastructure, and the ChatGPT UI is fine.
  • API when you need it inside your product, automated at scale, behind your own auth, or wired into a backend. If you need structured outputs (guaranteed JSON shapes) or programmatic orchestration with the Agents SDK, you are on the API.

A common path: prototype the behavior as a custom GPT to validate the instructions quickly, then port the proven instructions into an API integration when you need scale or a custom interface.

Maintaining a custom GPT

A published GPT is a small product. Treat it that way.

  • Version your instructions. Keep the instruction text in a file in your repo or notes. The builder has no real version history, so keep your own.
  • Re-test after model updates. Behavior can shift when the underlying model changes. Keep a short list of test prompts and rerun them.
  • Keep knowledge files current. A stale tone guide produces stale output, so re-upload when the source changes.
  • Audit Actions. If the GPT is public and calls an API, review what that endpoint exposes.

Key Takeaways

  • Use a custom GPT when a job repeats, the instructions are long and stable, the same files matter every time, or other people need to run it without seeing the setup. Use a saved prompt or Project for personal, fast-changing work.
  • Build in the Configure tab, not the conversational mode, so you control the exact instructions, knowledge files, capabilities, and recommended model.
  • Add Actions (with clear operationId and summary fields in an OpenAPI schema) when the GPT needs live data from your own endpoints. Use apps (formerly connectors) to pull in documents from services like Google Drive.
  • Remember the boundary: a custom GPT lives inside ChatGPT for ChatGPT users; the OpenAI API (Responses, function calling, structured outputs, Agents SDK) is for embedding the model in your own product. Prototype as a GPT, port to the API when you need scale.
  • Treat a published GPT as a product: version your instructions yourself, re-test after model updates, and keep knowledge files current.

Frequently asked questions

What is a custom GPT in ChatGPT?

A custom GPT is a configured version of ChatGPT that bundles a fixed system prompt, uploaded knowledge files, capability toggles, a recommended model, and optional API connections into a single named, shareable unit. You set it up once for a job you repeat, then reuse it or share it instead of rebuilding the setup each time. Building one requires a Plus, Pro, Business, Enterprise, or Edu plan, via the builder at chatgpt.com/gpts/editor.

When should I build a custom GPT instead of just saving a prompt?

Build a custom GPT when several people need the same behavior, when the instructions are long and stable, when the same reference files matter in every conversation, or when you need Actions to call your own API. A saved prompt or a ChatGPT Project is enough when it is just you, the prompt is short, or the context changes every time. Rough rule: Projects are for your own recurring work with shared files, custom GPTs are for packaging a repeatable job for other people.

What is the difference between a custom GPT and the OpenAI API?

A custom GPT lives inside ChatGPT: the user needs a ChatGPT account, the interface is fixed, and you configure it with instructions, files, and Actions without writing code. The OpenAI API (Responses, and the older Chat Completions) embeds the model in your own application, with your interface, your auth, payment per token, plus function calling, structured outputs, and the Agents SDK. A common path is to prototype the behavior as a custom GPT, then port the proven instructions to the API when you need scale or a custom interface.

How do GPT Actions work and when do I need one?

A GPT Action lets a custom GPT call an external API during a conversation, configured by pasting an OpenAPI schema into the Action editor and adding an auth method (API key or OAuth). You need one when the GPT must fetch live data from your own endpoint rather than guess, for example pulling approved product specs by SKU. The model decides when to call it based on your instructions and the action's operationId and summary, so vague summaries cause missed or wrong calls.

What is the difference between GPT Actions and ChatGPT apps (formerly connectors)?

Apps, which OpenAI previously called connectors, link ChatGPT to services like Google Drive, SharePoint, or GitHub so you can pull their content into chats and Projects. Actions are custom API calls you wire into one specific custom GPT through an OpenAPI schema. Use apps to bring in documents from supported services, use Actions to hit your own endpoint or trigger a custom operation.

What do I need to publish a GPT publicly in the GPT Store, and what changes once it is live?

Publishing publicly in the GPT Store requires a verified builder profile, either a name or a verified domain; the other visibility options are private, link-only, and workspace for Business, Enterprise, and Edu plans. Once live, the GPT runs on each user's own ChatGPT account and plan, so free users face tighter limits and may get different model access than you had while building, even with a recommended model set. Test it from a non-builder account before shipping, and treat any Action on a public GPT as a public door into that API.

What to do, from this lesson

These actions are compiled in the role's Playbook.

  • Toggle off every custom GPT capability not required by the task
  • Own team GPTs at workspace/admin level and publish workspace-only
See the full action playbook →

Related articles

Recent articles from the blog that build on this lesson.