Custom GPTs Guide: instructions, knowledge, and an OpenAPI Action

A custom GPT is a ChatGPT configuration: instructions, optional files, optional built-in tools, and optional HTTP calls described by an OpenAPI schema. This lab builds a read-only GPT that fetches one public post and explains it. It also records who can still create a GPT.

Who can build one

GPTs are available to signed-in ChatGPT users. Public GPT pages can be visible before sign-in, but chatting requires an account. Creating and editing happen on the web. The mobile apps can use a GPT; they cannot create one.

OpenAI is moving creators toward plugins, which bundle reusable instructions, reference files, and connected apps. After a GPT is migrated, the original becomes read-only. Custom Actions do not move across automatically. Set up and test a replacement before you depend on the plugin. This lab is for an existing GPT you can still edit, or a workspace that can still create one.

Configure the GPT

1. Open Explore GPTs in the sidebar, or visit https://chatgpt.com/gpts.
2. Select Create if your workspace still allows it. To change one you already own, open My GPTs, choose it, and select Edit GPT. From an open chat, the GPT menu also has Edit GPT.
3. Pick the conversational builder (you describe the GPT and ChatGPT drafts the fields) or the configuration view (you edit the fields).

Name, description, and starters

These are what other people see.

• Name. The title in search, the GPT Store, shared links, and the chat header. Use a specific name: “Post explainer”, not “Helper”.
• Description. One or two sentences: who it is for and which task it covers.
• Conversation starters. Three or four prompts a real user would send, such as “Fetch post 1 and list the fields” or “What is missing from this post id?”.

Instructions

Instructions run on every conversation. They set behavior. They are not the knowledge files.

Write them the way you would write a prompt spec: a role, the steps, the output shape, and a stop rule. OpenAI’s editor guidance is to prefer “do this” over a long list of bans, to use headings, and to include a short example when the GPT must classify or format something.

You explain public JSON posts for developers.

When the user gives a numeric id:
1. Call getPost with that id.
2. Show userId, id, title, and body in a four-row table.
3. Then one sentence on whether the title matches the body.

If the id is missing, ask for it. Do not invent a post.
If the call fails, show the HTTP error and stop.
Do not browse the web for a substitute post.
Quote the title and body from the tool result only.

Recommended model

The recommended model is a suggestion when someone starts a chat. If that model is not available to them, a similar one may be selected. Users who have other models can still switch. Leave it unset if you do not want to steer the choice. Actions are not available in Pro mode: the model selector then shows only non-Pro models that support Actions.

Knowledge files

Knowledge is reference material: a runbook, a glossary, a style guide. It is not where rules belong. Rules go in instructions.

As of October 2026 the caps are 20 files, 512 MB each. Common documents, spreadsheets, images, text, and code are accepted. The exact set depends on the model, and some types require Code Interpreter & Data Analysis.

Practical rules from the editor docs, restated for this lab:

• Prefer plain text or Markdown over a scanned PDF or a complex slide layout.
• If you want citations, say so in the instructions and name the format (“quote the heading, then the sentence”).
• After upload, ask a question in Preview whose answer exists only in the file. If the reply is generic, the file is not being used.

For this lab, add one small Markdown file, field-notes.md:

# Field notes

userId is the author id in the sample API, not a ChatGPT user.
title and body are placeholder text. Do not treat them as production content.

Capabilities

Turn on only what this GPT needs. Availability depends on account, workspace, and region.

This lab leaves web search off so the model cannot replace a failed API call with a web hit. Leave Apps off too: a GPT uses either Apps or Actions, never both at once.

Action: a public read API

An Action is two pieces: how the GPT authenticates, and an OpenAPI schema (JSON or YAML) that names the server, the paths, the parameters, and the operation ids.

The schema below points at JSONPlaceholder. A GET of https://jsonplaceholder.typicode.com/posts/1 returns a JSON object with userId, id, title, and body. No API key.

1. In the editor, open Actions and select Create new action.
2. Set authentication to None. The other documented choices are API key (Basic, Bearer, or a custom header) and OAuth (client id, client secret, authorization URL, token URL, scope, and token exchange method). The editor shows a callback URL for the OAuth flow.
3. Paste the schema, or import it from a URL. The editor also offers starter schemas (Weather as JSON, Pet Store as YAML, or a blank template). A valid schema lists the detected actions. An invalid one shows validation errors. The help page does not pin an OpenAPI minor version; if the editor rejects the document, fix the errors it prints.

openapi: 3.1.0
info:
  title: Public placeholder posts
  version: "1.0.0"
servers:
  - url: https://jsonplaceholder.typicode.com
paths:
  /posts/{id}:
    get:
      operationId: getPost
      summary: Read one placeholder post by numeric id
      parameters:
        - name: id
          in: path
          required: true
          schema:
            type: integer
            minimum: 1
      responses:
        "200":
          description: One post
          content:
            application/json:
              schema:
                type: object
                properties:
                  userId:
                    type: integer
                  id:
                    type: integer
                  title:
                    type: string
                  body:
                    type: string

4. Add a Privacy Policy URL on the action if you will share the GPT by public link or publish it to the GPT Store. Each public action needs a valid policy URL. This lab does not supply one; a private workspace GPT can stay invite-only without that step.
5. Ask in Preview: “Fetch post 1 and table the fields.” Confirm the call, if ChatGPT asks. The table should show the four fields from the response, not a paraphrased article.

Relevant parts of the user’s message can be sent to the third-party host. OpenAI does not control that host. Use this pattern only with an API you trust. For a private API, prefer a Bearer key or OAuth, and do not paste the key into the instructions.

Enterprise and Edu workspaces can allow every domain or an allowlist. If you see “No domains are allowed by your workspace’s settings,” an admin has to permit the host. A workspace set to zero allowed domains blocks custom Actions even if the GPT itself is visible. There is also an official ActionsGPT in ChatGPT for help writing schemas; this lab does not depend on it.

Test before you share

Preview is the test bench. Run these four checks:

Tighten the instructions before you add another capability. The editor saves a draft as you go. Select Create when you are making a new GPT in an eligible workspace, or Update when you are editing one that already exists. Open the ••• menu for version history. Restoring an older version that uses Actions can require you to set authentication again.

Sharing scope

Select Share in the editor. Options depend on plan and workspace. Personal accounts cannot publish a new GPT.

Documented sharing levels:

Permission on a share is Can chat, Can view settings, or Can edit. Public link sharing and the GPT Store only support Can chat. Direct sharing with specific users or groups is a managed-workspace feature. As of October 2026 that direct list can include up to 100 recipients; a group counts as one recipient. People you invite directly get an email with the link.

Publishing to the GPT Store can ask for a category, a look at your builder name or website, and a confirmation that the GPT meets policy. You may need a builder profile (your name, a website on a verified domain, and supported verified social profiles). Public publishing is blocked when the workspace disables it, when an app connection is not allowed for that share mode, when a public Action has no privacy policy URL, or when a policy check fails. Apps on a GPT can block public link sharing and Store publishing; remove the app connection and try again.

GPT builders cannot read other people’s conversations with the GPT. A GPT is not an embed for your own website. To put a model in a product, use the API. On the ChatGPT website, people can also type @ and pick your GPT inside an existing chat. That mention is not available in the iOS or Android apps.

Limits to plan around

• New creation is closed on personal plans and, for affected Enterprise workspaces, ended on 26 October 2026 (FedRAMP excepted).
• Retirement dates above are the ones published on the help center. Read the notice on your own workspace before you treat a date as yours. A deferral moves the FedRAMP-style date, not every workspace.
• Actions and Apps are mutually exclusive.
• Actions do not run in Pro mode.
• Actions fail closed when the workspace allowlist contains no domains.
• Knowledge is retrieval, not a guarantee the model will quote the file. Test it.
• Migrated GPTs become read-only, and their Actions are not copied for you.
• A GPT never inherits the user’s memory or custom instructions. If a rule matters, it has to be in this GPT’s instructions.

For tool use outside ChatGPT, compare this Action with a Model Context Protocol server and with the loop in agentic AI.

FAQ

How do I create a custom GPT?

Open Explore GPTs in the sidebar, or go to chatgpt.com/gpts, then Create. Use the conversational builder or the configuration view. Creation has to be enabled for your workspace. Personal ChatGPT accounts, including Free, Go, Plus, and Pro, cannot create or publish new GPTs.

Can ChatGPT Plus users still make a new GPT?

No. As of October 2026, new GPT creation and publishing are unavailable on personal accounts, including Plus and Pro. An existing GPT can still be used, and it can still be edited when the plan and permissions allow it.

How do GPT Actions work?

An Action is an OpenAPI schema plus an authentication choice: none, an API key, or OAuth. ChatGPT calls the operations in that schema. A GPT can use apps or Actions, not both. Users may be asked to approve a call before it runs.

Do custom GPTs use my ChatGPT memory?

No. A GPT does not use saved memory, your custom instructions, or previous conversations. Each conversation starts fresh. Put rules in the GPT’s instructions and reference material in knowledge files.

What are the knowledge file limits?

As of October 2026, a GPT can have up to 20 knowledge files, and each file can be up to 512 MB. Accepted types vary by model. Some types are available only when Code Interpreter & Data Analysis is enabled.