ChatGPT Custom Instructions Character Limit: Official Limit, Scope, and Workarounds

You wrote a beautiful set of instructions. You paste it into the settings screen. The field stops accepting text halfway through your third rule, and the save button does nothing until you hack away at what you already wrote. That wall is 1,500 characters per field, and most people hit it without ever reading the number.

The character cap is not the real problem. The real problem is that people treat the box like a diary when it works like a budget. Below is what the ceiling actually is, where your instructions do and don't apply, and what to move where once your rules outgrow the space.

What Is the Official ChatGPT Custom Instructions Character Limit?
Where Do Custom Instructions Apply?
How Do You Fit Useful Rules Into 1,500 Characters?
What Should You Use When 1,500 Characters Are Not Enough?
Why Can ChatGPT Ignore Valid Custom Instructions?
How Should You Govern and Maintain Custom Instructions?
Key Recap
FAQs

Quick Summary

- What this covers: the confirmed Custom Instructions cap, where those instructions reach, and what to do when they stop fitting.

- Who it's for: anyone who writes rules for ChatGPT and keeps running into a save button that won't cooperate.

- Key takeaway: the limit rewards short durable rules and punishes pasted context; the fix is compression plus the right container.

What Is the Official ChatGPT Custom Instructions Character Limit?

Guessing at the number wastes an afternoon. OpenAI documents the cap directly: each of the longer Custom Instructions fields accepts 1,500 characters. There are two of those fields, "What would you like ChatGPT to know about you" and "How would you like ChatGPT to respond," and the ceiling applies to each one separately, not to the pair as a shared pool. So the practical envelope is roughly 3,000 characters of standing behavior, split across two purposes.

Every keystroke counts against you. A character is a character. Spaces, line breaks, punctuation, and emoji all draw down the same 1,500. A tidy bulleted list with blank lines between items reads well to you and burns budget you could have spent on an actual rule. Watch what the counter does when you strip decorative whitespace: the text says the same thing and you get 80 characters back.

The cap holds across surfaces. Web, desktop, iOS, and Android read from the same saved settings, so a rule written on your laptop travels to your phone without a second copy. What you should treat as interface observation rather than promised behavior is exact live-counter placement, since OpenAI revises the settings screen without changing the underlying number.

| Attribute | Confirmed behavior |

|---|---|

| Per-field maximum | 1,500 characters |

| Fields governed | Two longer-form fields, counted independently |

| Counted characters | Letters, spaces, line breaks, punctuation, emoji |

| Platform consistency | Same limit on web, desktop, iOS, Android |

| When edits apply | New chats after saving; existing threads keep their prior context |

Saved edits are forward-looking. When you change the text and save, the next conversation you start reads the new version. Threads already open do not retroactively rewrite themselves. That single detail explains half the "it ignored my update" complaints, and it sets up the failure modes the later sections cover. For the behaviors the cap can't explain, the limitations of custom instructions matter more than the number.

Where Do Custom Instructions Apply?

People smear one instruction set across every context and then wonder why project work bleeds into personal chats. The scopes are distinct, and OpenAI's product documentation draws the lines.

Global Custom Instructions load into every new chat you start, unless a narrower scope overrides them. This is your baseline personality and standing preferences.
ChatGPT Projects carry their own instruction field plus attached sources. Project instructions take precedence inside that project, so a project can override or extend your global rules for that body of work only.
Custom GPTs built in the GPT Builder hold instructions scoped to that single assistant. They travel with the GPT, not with your account, which is why a shared Custom GPT behaves the same for everyone who opens it.
ChatGPT Memory is not an instruction field at all. It stores facts the model has picked up or you've asked it to remember, and it persists across chats as recalled information rather than a rule you authored.
The context window is the live working space of a single conversation, measured in tokens, not a saved setting. It governs how much of the current thread the model can see at once.

|---|---|---|---|

Confusing the character cap with the context window is the most expensive mistake here, because it sends people compressing rules to solve a capacity problem that lives somewhere else entirely. If your instructions keep drifting toward project-specific detail, that content belongs in a project, not your global fields.

How Do You Fit Useful Rules Into 1,500 Characters?

The blank field tempts you to write prose. Prose is where the budget dies. Treat 1,500 like a line-item ledger and cut anything that isn't a behavior the model can act on.

Start by counting before you paste. Any plain-text editor with a live word/character count, a quick Get-Content | Measure-Object -Character, or a browser character counter tells you where you stand before the save button embarrasses you. Draft outside the box, measure, then move the trimmed version in.

Prioritize durable behavior over disposable context. A rule like "answer in tight bullet points, no preamble" changes every reply forever. A line like "I'm currently researching a trip to Lisbon" is stale in a week and eats space a standing rule could hold. Keep the first kind. Delete the second, or push it into a project.

Watch a real compression pass:

Before (168 characters): "I would really appreciate it if you could try to keep your responses relatively concise and to the point, and please avoid adding unnecessary introductory preambles."
After (54 characters): "Be concise. No preambles. Answer the question first."

That is 114 characters reclaimed from one sentence, and the second version is easier for ChatGPT to follow because the command is unambiguous. Compact structure beats polite paragraphs: short imperatives, one rule per line, no hedging verbs.

Strip conflicts and duplicates. "Be thorough" three lines above "keep it short" is not two rules, it's a coin flip. Pick one, delete the other. Then test the compressed set by throwing it a prompt it should visibly change, and confirm the behavior shifts. If a rule never alters output, it was decoration.

What Should You Use When 1,500 Characters Are Not Enough?

Sometimes the honest answer is that your rules don't belong in the box. Fighting the cap with denser and denser abbreviations produces instructions only you can read. Match the container to the job instead.

|---|---|---|---|---|---|

Reference material is not an instruction. If half your text is background a model should read rather than obey, attach it as a knowledge file or a project source and let the instruction field hold only the rules. Move project-specific context into a ChatGPT Project when the work is bounded and ongoing, and into a Custom GPT when you want a repeatable assistant others can open, the way you'd weigh ChatGPT Projects against Claude Projects.

For application control, the OpenAI API gives you a system message and developer message that sit outside the chat UI entirely. That is the layer where hard behavioral guarantees belong, because it is enforced in code, not requested in a settings box.

The Short Version: The 1,500-character cap rewards short durable rules and punishes pasted context, so compression means cutting disposable detail, not shrinking your intent.

Why Can ChatGPT Ignore Valid Custom Instructions?

Your text fit the limit, saved clean, and the model still did the thing you told it not to. That does not mean the cap failed. It means you mistook a preference for a contract.

Custom Instructions are steering, not law. They bias behavior; they do not bind it. When you write "never use bullet points" and the model bullets anyway, you've discovered the difference between a preference and a hard constraint, and that gap is exactly why custom instructions fail even when the text is perfect.

Overload and ambiguity make it worse. Fifteen competing rules give the model a menu, not a spec. A vague line like "be professional but casual" hands it a contradiction to resolve however it likes. Fewer, sharper rules win more often than a wall of qualifiers.

The current prompt outranks the standing rule. Ask for a long detailed essay and your saved "be concise" loses, because the immediate request is a stronger signal than a background preference. That is intended behavior, not a bug.

Following also varies by model. The same saved text can be honored more tightly by one model and loosely by another, since instruction adherence is a property of the model, not the text alone. And remember the forward-looking rule from earlier: an edit changes new chats, so a thread you opened this morning still runs on this morning's version.

To separate a character-limit failure from an instruction-following failure, run a controlled test:

Trim the instruction set to a single unambiguous rule, well under 1,500.

Open a fresh chat and prompt something that rule should change.

If it obeys, your problem was overload or conflict, not the cap.

Reintroduce rules one at a time until the behavior breaks. The rule that breaks it is your culprit.

How Should You Govern and Maintain Custom Instructions?

Instructions rot quietly. Nobody versions them, so nobody notices when a rule drifts out of use or a workspace policy quietly overrides it. Treat the text as an asset with a paper trail.

Your instructions travel in a data export. OpenAI's export includes account settings, so your saved rules leave with your data and are not stranded behind the UI. On account deletion, that content follows OpenAI's retention and deletion policy along with the rest of your account data, rather than persisting as an orphaned setting.

Workspace controls can constrain what you assumed was yours to set. On team and enterprise plans, admin policy can limit or shape instruction behavior and availability, so a rule that works on a personal account may be restricted under a managed workspace. Check the inherited policy before you blame the model.

Keep version history outside the box, because the field itself shows only the current text. A dated file in a notes app or a repo gives you a diff when behavior changes and a rollback when an edit backfires. Store the distinction between saved rules, remembered facts, and conversation capacity too, since the ChatGPT Memory limit is a separate ceiling people conflate with this one.

Before you move a rule set between global settings, a ChatGPT Project, and a Custom GPT, run this change-control checklist:

Copy the current text into dated external storage first.
Confirm the target scope: global, project, or GPT.
Recount characters against the target's own limit.
Remove rules the new scope makes redundant.
Test one behavior-changing prompt in the new scope.
Log what moved, where, and why.

Take Action: aifirstsearch.com - Compress your rules to durable behaviors, then get the AI memory setup at /setup.html.

Key Recap

The confirmed cap is 1,500 characters per longer-form field, counted independently, on every platform.
Everything counts against it, including spaces, line breaks, and emoji.
Edits apply to new chats; open threads keep their old context.
Global rules, ChatGPT Projects, Custom GPTs, ChatGPT Memory, and the context window are distinct scopes with different precedence and persistence.
Compression means cutting disposable context and duplicate rules, not shrinking the container.
When rules outgrow the box, move them to files, Projects, Custom GPTs, or the OpenAI API by capacity and control.
A valid instruction can still lose to overload, ambiguity, the live prompt, or model variation.
Version instructions externally and check workspace policy before you trust the setting.

FAQs

Does the 1,500-character limit apply to both fields combined?

No. Each longer-form field gets its own 1,500 characters. They are counted separately, giving you roughly 3,000 characters of standing instruction split across the two purposes.

Do spaces and line breaks count toward the limit?

Yes. Every character draws down the budget, including spaces, line breaks, punctuation, and emoji. Stripping decorative whitespace is the fastest way to reclaim room.

Why does ChatGPT ignore an instruction that clearly fits?

Because instructions are preferences, not hard constraints. A conflicting live prompt, an overloaded rule set, ambiguous wording, or model-to-model variation can all override text that saved perfectly well within the cap.

Is the character limit the same as the context window?

No. The cap is a fixed character count on a saved setting. The context window is the token-measured working memory of a single live conversation. They are unrelated ceilings.

When do edits to custom instructions take effect?

On the next chat you start after saving. Conversations already open continue running on the instruction version that was active when they began.