OpenAI Assistants API shuts down 26 August 2026: a 3-week migration sprint plan

Summary. OpenAI removes the Assistants API on 26 August 2026, three weeks from today. The deprecation was announced on 26 August 2025 with a full year of notice, and OpenAI's documentation now files Assistants under "Legacy APIs" alongside Agent Builder, Evals and self-serve fine-tuning. The replacement is the Responses API plus the Conversations API, and the object mapping is short: Assistants become Prompts, Threads become Conversations, Runs become Responses, Run steps become Items. Two things about this migration are consistently underestimated. First, tool-call orchestration moves into your application code, OpenAI's own guide states that with Responses, "tool call loops are explicitly managed". Second, the cost shape changes even though the token rates do not: OpenAI's pricing page is explicit that "Responses API, Chat Completions API, Realtime API, Batch API, and Assistants API are not priced separately", yet file-search tool calls at $2.50 per 1,000 apply "to the Responses API only", and Code Interpreter has moved from a one-hour session to a 20-minute container billed from $0.03 to $1.92 depending on size. A workload that ran on 1-hour Code Interpreter sessions and heavy file search can cost meaningfully more after a like-for-like port. Three weeks is enough time to do this properly. It is not enough time to discover the cost change in your September invoice.

There is also a trap in the recommended path. OpenAI tells you to recreate each Assistant as a reusable prompt object, and reusable prompt objects are themselves deprecated, with the v1/prompts API scheduled to shut down on 30 November 2026. Migrating straight onto prompts means migrating onto a second deprecated object with a 96-day life.

What is actually being removed, and when

OpenAI's deprecations page records the sequence precisely: "On August 26th, 2025, we notified developers using the Assistants API of its deprecation and removal from the API one year later, on August 26, 2026." The migration guide repeats the date in a banner: "After achieving feature parity in the Responses API, we've deprecated the Assistants API. It will shut down on August 26, 2026."

OpenAI's own definitions matter here, because "deprecated" and "shut down" are not the same thing on this platform. From the deprecations page: "We use the term 'deprecation' to refer to the process of retiring a model or endpoint… All deprecated models and endpoints will also have a shut down date. At the time of the shut down, the model or endpoint will no longer be accessible." And: "We use the terms 'sunset' and 'shut down' interchangeably to mean a model or endpoint is no longer accessible."

The Assistants API has been deprecated for a year. On 26 August 2026 it becomes inaccessible. Any client.beta.threads.* call in your codebase stops working on that date.

The Assistants shutdown is one of five endpoint retirements OpenAI has scheduled across late 2026. The table below is the calendar worth putting on a wall, because teams often migrate off one of these and straight onto another.

Read that table before you design your migration, not after. The path OpenAI's own migration guide recommends, recreate Assistants as dashboard prompts — lands you on a row that expires 96 days after the row you are escaping.

The object mapping

OpenAI's migration guide gives the mapping directly:

Notice the row that is not a rename. Runs to Responses changes who runs the loop. Under Assistants, a run entered requires_action, you submitted tool outputs, and OpenAI resumed the run. Under Responses, as OpenAI puts it, "Your application code now handles orchestration (history pruning, tool loop, retries) while your prompt focuses on high-level behavior and constraints." That is the migration's real work item. Everything else is renaming.

The code change

The before-and-after in OpenAI's guide is unusually stark. Here is the polling shape you are removing:

            run = openai.beta.threads.runs.create(
    thread_id=thread_id,
    assistant_id=assistant_id,
)

while run.status in ("queued", "in_progress"):
    time.sleep(1)
    run = openai.beta.threads.runs.retrieve(thread_id=thread_id, run_id=run.id)
          

And the shape you are moving to:

            response = openai.responses.create(
    model="gpt-5.6",
    input=[{"role": "user", "content": "What are the 5 Ds of dodgeball?"}],
    conversation=conversation_id,
)
          

Thread creation becomes conversation creation, with messages becoming items:

            # Before
thread = openai.beta.threads.create(
    messages=[{"role": "user", "content": "what are the 5 Ds of dodgeball?"}],
    metadata={"user_id": "peter_le_fleur"},
)

# After
conversation = openai.conversations.create(
    items=[{"role": "user", "content": "what are the 5 Ds of dodgeball?"}],
    metadata={"user_id": "peter_le_fleur"},
)
          

In OpenAI's full chat-application example, a 34-line handler with a polling loop becomes a 17-line handler with one call. The response object carries conversation, previous_response_id, store and background fields; the guide notes that using a conversation object "lets you manage conversations instead of passing back previous_response_id".

One field disappears quietly and is worth checking for in your code. The thread object had tool_resources; the conversation object in OpenAI's example does not. If you attached per-thread vector stores or Code Interpreter files through tool_resources, that wiring has to be rebuilt on the Responses side.

Three things the guide says you have to do by hand

These are the items that turn a "rename some calls" estimate into a real sprint.

Assistants can no longer be created via API. OpenAI is explicit: prompts "can only be created in the dashboard, where you can version them as you develop your product." If you provision assistants programmatically — one per tenant, one per workflow, one per customer — that pattern has no successor. OpenAI's suggested mitigation is to "Store the prompt ID (or its exported spec) in source control so application code can refer to a stable identifier" and to "run A/B tests by swapping prompt IDs—no need to create or delete assistant objects programmatically." For a single-tenant product that is fine. For a multi-tenant SaaS that spun up an assistant per customer, it is a redesign.

There is no automated thread migration. In OpenAI's words: "We will not provide an automated tool for migrating Threads to Conversations. Instead, we recommend migrating new user threads onto conversations and migrating older ones as necessary." That implies a dual-path period where new sessions run on Conversations and old ones still read from Threads — and Threads stop existing on 26 August 2026, so any history you want to keep has to be copied before that date.

The backfill script OpenAI publishes handles two content types:

            for content in m.content:
    match content.type:
        case "text":
            item_content_type = "input_text" if m.role == "user" else "output_text"
            item_content += [{"type": item_content_type, "text": content.text.value}]
        case "image_url":
            item_content += [{
                "type": "input_image",
                "image_url": content.image_url.url,
                "detail": content.image_url.detail,
            }]

conversation = openai.conversations.create(items=items)
          

There is no case for file attachments, tool outputs, or annotations. Citations from file search in historical threads are dropped by this script. If your product shows source citations on past conversations, extend the script or accept the loss knowingly.

The recommended target is deprecated. The migration guide itself carries the warning: "Reusable prompt objects are also being deprecated. If you use this migration path, review the prompts deprecation timeline before adopting prompt objects in a long-lived integration." Our advice for anything with a life beyond this year: skip prompts, put instructions and tool schemas in your own code under version control, and pass them on each responses.create call. You get the same versioning benefit from your existing Git history, and you do not repeat this exercise in November.

The cost changes nobody prices in

OpenAI's pricing page states plainly that the API surface itself is not a billing dimension: "Responses API, Chat Completions API, Realtime API, Batch API, and Assistants API are not priced separately. Tokens are billed at the chosen model's input and output rates." So a straight port with the same model and the same token volume costs the same. Two tool lines are where the change hides.

Work the second and fourth rows against your own volumes before you commit to a design. A support assistant handling 200,000 retrieval-backed conversations a month, each making one file-search call, picks up a $500 monthly line that did not exist on the same workload under Assistants. And a data-analysis assistant whose users keep a Code Interpreter session alive for an hour was paying $0.03 for that hour; on the 1 GB container tier the same hour spans three sessions.

The honest framing: for most chat workloads the migration is cost-neutral and the code gets shorter. For retrieval-heavy and Code Interpreter-heavy workloads, model the tool lines first. The right time to renegotiate an architecture is while you are already rewriting the call sites.

The three-week sprint plan

Twenty-one days from 5 August 2026 to the shutdown. This is the shape we would run it in.

Two notes on sequencing. Do the cost model in week 1, not week 3 — if the numbers argue for changing the retrieval design, you want that decision before you rewrite the call sites, not after. And cut over by cohort rather than by feature flag percentage, because conversation state is per user: a user who flips mid-session between Threads and Conversations loses context.

If you slip past 26 August, the failure is not graceful. Calls to a shut-down endpoint fail, and an assistant-backed feature in a production application fails with them.

India-specific considerations

Three points for Indian teams and for engineering leaders in Gurugram, Bengaluru, Pune and Hyderabad running this migration for global customers.

Data residency has a listed price now. OpenAI's pricing page states that "Regional processing (data residency) endpoints are charged a 10% uplift for models released on or after March 5, 2026, that are eligible for data residency." If your Digital Personal Data Protection Act 2023 posture, or a customer contract, requires regional processing, that uplift belongs in the migration cost model rather than arriving as a surprise. Teams should also note that OpenAI models served through Amazon Bedrock "are billed through AWS and may differ from direct OpenAI pricing", which changes the arithmetic if you route through a cloud marketplace for procurement reasons.

Conversation storage is a data-governance decision, not just an API one. Conversations persist items server-side by default — the response object shows "store": true. Under Assistants your threads were already server-side, so this is not new, but a migration is the natural moment to decide what you actually need retained, for how long, and whether transcripts belong in your own store instead. Teams handling health, financial or identity data should make that call deliberately.

On staffing, three weeks is a sprint, and this work needs someone who has held the tool-call loop before. The orchestration that OpenAI used to run inside a run — retries, tool timeouts, partial failures, history pruning — is code you now own and have to get right under a deadline. This is the part where teams with no prior agent-loop experience lose a week.

What good looks like after the migration

The end state is worth naming, because "it still works" is a low bar for a rewrite you were forced into.

Instructions and tool schemas live in your repository, versioned with your application, not in a dashboard object with its own deprecation date. The tool-call loop is explicit, tested and instrumented, so a tool that starts timing out shows up on a dashboard rather than as a slow conversation. Retrieval calls are counted, because they are now billed. Conversation retention is a decision someone made, with a stated period. And the legacy path is deleted rather than flag-disabled, so nobody re-enables it in a rollback six months from now.

That is a better system than the one you had. The migration is not optional, so the only real choice is whether you get that improvement out of it or just survive the date.

FAQ

How eCorpIT can help

eCorpIT runs exactly this kind of deadline-bound migration: inventory the assistants and call sites, model the tool-cost change against your actual usage before any code moves, rebuild the tool loop with tests and instrumentation, and cut over by cohort with the backfill run against a copy first. Founded in 2021 and based in Gurugram, we are CMMI Level 5 and ISO 27001:2022 certified, and our senior engineering teams design AI systems aligned with DPDP requirements. Typical engagements here are a scoped three-week sprint with a named engineering lead, sized after a short discovery call. If 26 August is on your calendar without an owner, talk to us.

Related reading: our AI agent pilot to production service covers the orchestration and evaluation work this migration exposes, the enterprise AI agents production guide is the pillar for this cluster, and the Assistants API to Responses migration walkthrough and Azure OpenAI Assistants to Foundry Agents guide cover the direct-OpenAI and Azure paths respectively. For teams reconsidering the model alongside the API, our LLM migration and cost optimization service covers the pricing analysis.

References

1. Assistants migration guide (object mapping, code samples, backfill script) — OpenAI

1. Deprecations — OpenAI API

1. Pricing (model rates, tool pricing, data residency uplift) — OpenAI API

1. Assistants API deep dive — OpenAI

1. Responses API reference — OpenAI

1. Migrate from prompt objects — OpenAI

1. Migrate from Agent Builder — OpenAI

1. Your data: regional processing and data residency — OpenAI

1. Fast mode (renamed from Priority processing, 30 July 2026) — OpenAI

1. OpenAI models in Amazon Bedrock — OpenAI

1. File search tool guide — OpenAI

1. Code Interpreter tool guide — OpenAI

1. OpenAI API changelog

Last updated: 5 August 2026.