Migrating from OpenAI Prompt Objects Before the November 30 Shutdown

OpenAI has published the sunset schedule for Prompt Objects, the feature that let you store a prompt in the dashboard, give it an id, and reference it from the Responses API with prompt: { id, version, variables }. Prompt creation was de-emphasised on 3 June 2026, the evals surface goes read-only on 31 October, and on 30 November 2026 the v1/prompts API stops answering. Any request that still references a prompt id fails from that day.

If your production code contains prompt: { id: "pmpt_..." }, you have a deadline.

What Prompt Objects gave you

Prompt Objects were a small feature with a big effect on how teams worked:

• A prompt lived outside the codebase and had a stable id.
• Every edit in the Playground created a new version; production could pin one.
• {{ variables }} were substituted server-side from the variables map you passed.
• Product people could change the wording without a deploy.

OpenAI's own migration guidance is to move prompts back into version-controlled files in your repository. That preserves history, but it gives up the part most teams valued: a wording change no longer needs a release. It also only ever worked for OpenAI models.

What to look for in a replacement

The replacement has to keep the four properties above and, ideally, fix the vendor lock-in. Concretely:

1. Stable ids and a fetch call that returns the text your model call needs.
2. Versions with a production pointer and rollback, so a bad edit is a one-click revert rather than an incident.
3. Variables with the same {{ name }} syntax, so prompts move over without rewriting.
4. Vendor neutrality: the same prompt id should work whether the request goes to OpenAI, Anthropic or Google.
5. An editor that a non-engineer can use safely, with history.

SuperPrompts was built around exactly that list, so the rest of this post uses it. The steps apply to any prompt manager with a REST read path.

Step 1: Inventory

List every prompt id your code references:

grep -rn "pmpt_" src/ | sort -u

For each id, open it in the OpenAI dashboard and note the production version, the variables it expects, and any model configuration (model name, temperature, tools). Export the text of the production version. If several versions are in use across environments, export those too.

Step 2: Recreate

Create a project in SuperPrompts (one per application is the usual shape; each project has its own API key). Then create each prompt. Two ways:

Paste as markdown. Headings become sections, {{ variables }} are detected automatically and listed in the editor sidebar. Publish the first version.

Or script it. The write API takes the same content:

curl -X POST https://superprompts.app/api/v2/prompts \
  -H "x-api-key: $SUPERPROMPTS_API_KEY" \
  -H "content-type: application/json" \
  -d '{
    "name": "Support agent",
    "markdown": "# Role\nYou help {{ customer }} with {{ topic }}.\n\n# Rules\n1. Never promise refunds.",
    "publish": true
  }'

The response contains the new prompt id and its version hash. Keep a small mapping file from old pmpt_ id to new id for the next step.

Model configuration does not belong in the prompt manager. Keep model, temperature and max_tokens in your code, next to the call. That is where they are versioned with the code that depends on them.

Step 3: Swap the fetch

Before:

const response = await openai.responses.create({
  model: 'gpt-5',
  prompt: {
    id: 'pmpt_abc123',
    variables: { customer: user.name, topic: ticket.topic }
  },
  input: userMessage
});

After:

import { SuperPrompts } from 'superprompts'; // npm install superprompts
 
const sp = new SuperPrompts({ apiKey: process.env.SUPERPROMPTS_API_KEY! });
 
const { prompt } = await sp.getPrompt('NEW_PROMPT_ID', {
  variables: { customer: user.name, topic: ticket.topic },
  strict: true // fail fast if a variable is missing
});
 
const response = await openai.responses.create({
  model: 'gpt-5',
  instructions: prompt,
  input: userMessage
});

Python is the same shape:

from superprompts import SuperPrompts  # pip install superprompts
 
sp = SuperPrompts(api_key=os.environ["SUPERPROMPTS_API_KEY"])
prompt = sp.get_prompt("NEW_PROMPT_ID", variables={"customer": user.name})
 
response = client.responses.create(model="gpt-5", instructions=prompt.prompt, input=user_message)

The SDK caches each prompt for five seconds by default, so a busy endpoint makes one fetch per prompt every few seconds rather than one per request. Set cacheTtlMs (or cache_ttl) higher if your traffic is bursty and a slightly delayed rollout is acceptable.

What you gain in the move

• Any model. The same prompt id feeds OpenAI today and Anthropic tomorrow. The playground runs a version against both before you publish.
• Staging reads the draft. getPrompt(id, { version: 'latest' }) in staging, production by default everywhere else. No duplicate prompt to keep in sync.
• Your coding agent can edit prompts. SuperPrompts is also an MCP server: claude mcp add --transport http superprompts https://superprompts.app/api/v2/mcp --header "x-api-key: ..." and Claude Code or Cursor can read, update and publish prompts from the terminal.
• Rollback is a pointer move. Publishing an older version takes effect on the next request.

Checklist

• [ ] Every pmpt_ id inventoried with its production version and variables
• [ ] Each prompt recreated and published, mapping file saved
• [ ] Fetch calls swapped; strict variables enabled in tests
• [ ] Staging pointed at latest, production at the published version
• [ ] Old ids removed from the codebase before 30 November 2026

The whole thing is an afternoon for a typical application with a dozen prompts. Do it before the week it becomes urgent.

SuperPrompts keeps versioned system prompts behind one REST call, with Node and Python SDKs and an MCP server for Claude Code and Cursor. Start free: the free plan covers one project with five prompts.