The OpenAI Assistants API shuts down permanently on August 26, 2026. Every call to /v1/assistants, /v1/threads, and /v1/runs returns an error that day -- no grace period, no extension, no degraded mode. The replacement is the Responses API (stateless) paired with the Conversations API (opt-in persistence). Migration takes 2-6 weeks of real engineering work.
I audited three projects this week that are still running fully on Assistants. Twenty-five days is enough time to migrate -- but not if you wait until next week. Here is the exact sequence to follow.
What exactly shuts down on August 26?
Every endpoint in the Assistants API family goes offline simultaneously on August 26, 2026. That includes /v1/assistants (create, list, retrieve, modify, delete), /v1/threads, /v1/threads/{thread_id}/runs, /v1/threads/{thread_id}/messages, and /v1/threads/{thread_id}/runs/{run_id}/steps. OpenAI's official deprecations page at developers.openai.com/api/docs/deprecations lists the sunset with no extension noted.
OpenAI announced the deprecation exactly one year in advance -- August 26, 2025 -- via the OpenAI Developer Community forums. The announcement was explicit: no extension option. No grace period, no read-only window, no soft deprecation. The API is live on August 25. It is gone on August 26. One developer in the thread put the mood plainly: "I've been building a product around it. And now I'm being told there is a new API."
The shutdown has real reach. OpenAI has roughly 2.1 million developers actively building on the platform, per SocialCrawl's migration analysis. Assistants represents a "single-digit slice" of that total -- but the slice includes a large number of production customer support bots, document Q&A systems, and multi-step agent workflows built during the 2024-25 builder rush.
What replaces the Assistants API?
OpenAI maps old concepts directly to new ones. Assistants become Prompts (configuration bundles stored in the OpenAI dashboard). Threads become Conversations (a durable conversation_id you pass between requests). Runs become Responses (the synchronous API call). Run Steps become Items. The Responses API is stateless by default; the Conversations API adds opt-in persistence. This is a new architecture, not a renamed wrapper.
The operational change is significant. In Assistants, state lived server-side inside Thread and Run objects -- you created a Run, polled it until completion, then listed Thread messages for output. That is six API operations minimum for one exchange. In Responses, you make one synchronous call: send input items, get output items back. No polling loop, no thread management, no run lifecycle. If you need multi-turn memory, you pass a conversation_id. Persistence is a choice, not the default.
Three capabilities are on Responses API that were never in Assistants: deep research (web browsing with citations), remote MCP server connections, and computer use. Migrating is the only path to access them.
Get the AI Agent Briefing
One email per week. The best AI agent news, tutorials, and tools -- written by someone who actually builds with them.
Subscribe Free
What the code change actually looks like
The Assistants API required an async polling loop because runs were asynchronous -- you created a run, then checked its status until it moved from "queued" to "in_progress" to "completed." The Responses API is synchronous: one call returns the full response immediately. Here is the before and after for a typical assistant interaction in Python.
Before -- Assistants API (polling loop required):
import asyncio
import openai
# Create run and poll until complete
run = openai.beta.threads.runs.create(
assistant_id=ASSISTANT_ID,
thread_id=thread_id
)
while run.status in ("queued", "in_progress"):
await asyncio.sleep(1)
run = openai.beta.threads.runs.retrieve(
thread_id=thread_id,
run_id=run.id
)
# Read output from thread messages list
messages = openai.beta.threads.messages.list(thread_id=thread_id)
print(messages.data[0].content[0].text.value)
After -- Responses API (synchronous, no polling):
import openai
response = openai.responses.create(
prompt={"id": PROMPT_ID},
input=[{"role": "user", "content": message}],
conversation=conversation_id, # None for first turn
)
print(response.output_text)
The polling loop is gone. The run lifecycle is gone. For a first-turn call, set conversation=None and store the returned conversation_id. Pass it on the next call to maintain context. The full API reference is at developers.openai.com/api/docs/assistants/migration.
The 25-day migration checklist
Production-grade migrations from Assistants to Responses take 2-6 weeks of real engineering effort, per multiple practitioners who have tracked this transition. With 25 days remaining, the window is tight but workable if the audit starts today. Here is the prioritized sequence.
Days 1-3: Audit every Assistants API touchpoint. Search your codebase for openai.beta.assistants, openai.beta.threads, client.beta, /v1/assistants, and any Assistant IDs hardcoded in environment variables or config files. List every file and every environment -- dev, staging, prod. Do not estimate scope; run the search and count the actual files.
Days 4-7: Build a Responses API prototype. Before touching production, create one end-to-end flow using the Responses API. Send a stateless call, confirm the output_text field maps to whatever downstream code reads the response, and verify your prompt configuration matches your existing Assistant's instructions behavior.
Days 8-12: Decide your state management strategy. If your app has genuine multi-turn conversations that persist across sessions, prototype the Conversations API now and confirm conversation_id chaining works end-to-end. If your app is effectively stateless -- single-turn classification, session-scoped chatbots that reset, batch processing jobs -- you may not need Conversations at all. Stateless Responses is architecturally simpler than Threads was.
Days 13-17: Migrate your Assistants configuration to Prompts. Every Assistant has instructions, a model setting, and tool configurations. Recreate these as named Prompts in the OpenAI dashboard, then reference them by ID in your Responses calls via the prompt parameter. OpenAI has confirmed they will not provide an automated migration tool for Assistants-to-Prompts. This step is manual.
Days 18-22: Rebuild tool calls and file handling. If you use file_search or function_calling in Assistants, the integration pattern differs in Responses. Code Interpreter was priced at $0.03 per session and File Search at $0.10 per GB per day in Assistants -- pricing on Responses differs and is worth auditing separately. Test every tool integration against the official migration guide before moving to production.
Days 23-25: Feature-flag cutover. Route 10% of production traffic to the Responses path, watch error rates and output quality, then increment to 100%. Keep the old Assistants code in a disabled branch -- not deleted -- until after August 26. Old code is useful for debugging behavior differences that surface post-cutover, and deleting it before the deadline removes your fallback reference.
The hard part: migrating thread history
OpenAI will not automatically migrate your Thread data to Conversations. Threads and Conversations are separate data models with no built-in conversion path. OpenAI's official guidance is to migrate new user sessions to Conversations first, then backfill historical thread data as needed -- meaning if you need old conversation history to carry forward, you write your own export-and-import pipeline before August 26.
For most production systems, letting historical threads expire naturally is the practical choice. New sessions start on Conversations; old threads remain readable through August 25. If your product depends on long-term conversation memory -- customer support bots with multi-month ticket history, assistants that reference prior sessions by name -- the backfill pipeline needs to start this week.
A useful shortcut for systems where historical context is mostly about continuity rather than complete recall: dump the last N thread messages into your first Conversations turn as initial context items when a returning user starts a new session. It preserves the feeling of continuity without requiring a full data migration pipeline.
Azure OpenAI: your deadline is different
If you are running on Azure OpenAI, the August 26 shutdown does not apply to you directly. Microsoft has confirmed the Azure OpenAI Assistants API retires in February 2027 -- approximately six months after the direct OpenAI API. You have more runway, but the migration target also differs: Azure routes to Microsoft Foundry Agents, not OpenAI's Responses API. Before following this checklist, check Microsoft's Azure migration guidance -- the architecture and timeline are different.
FAQ
Will the OpenAI Assistants API be extended past August 26, 2026?
No. OpenAI stated explicitly in the original deprecation announcement that there is no extension option. Every request to /v1/assistants, /v1/threads, and /v1/runs returns an error after August 26, 2026. There is no degraded mode, no read-only grace period, and no announced exception for legacy integrations.
Does Azure OpenAI Assistants also shut down on August 26?
No. Microsoft confirmed the Azure OpenAI Assistants API has a separate retirement date of February 2027, not August 26, 2026. Azure users have roughly six additional months. The recommended migration target for Azure is Microsoft Foundry Agents, not OpenAI's Responses API directly. Check Microsoft's Azure deprecation Q&A for current guidance before starting your migration.
How long does migration from Assistants to Responses API take?
Production-grade migrations take 2-6 weeks of real engineering effort. Simple stateless assistants migrate in days; systems with heavy thread history, file_search integrations, and complex function-calling loops sit toward the longer end. OpenAI confirmed they will not provide an automated Thread-to-Conversations migration tool -- any history backfill requires custom code. Start the audit today if you have not already.
Get the AI Agent Briefing
One email per week. The best AI agent news, tutorials, and tools -- written by someone who actually builds with them.
Subscribe Free