Today is the day developers have been circling on their calendars since late August. The OpenAI Cursor cutoff arrives on 12 November 2026, the date OpenAI proposed for ending the supply of its models to Cursor, the AI code editor now owned by SpaceX. If you write code in Cursor with a GPT model selected, this is the morning to check what you are actually running on — because after today, the GPT options in Cursor’s model picker are living on borrowed time.
Before anyone panics, here is the honest picture. The OpenAI Cursor cutoff is real, it is dated today, and OpenAI has been clear about why it is happening. But the date itself is still, in OpenAI’s own words, a proposal. Neither company has confirmed a final termination date, and talks between the two sides were still going on as recently as this week. What follows is everything we know for certain, what is still unconfirmed, the three official ways to keep using OpenAI models inside Cursor, and the switches that make sense if you would rather move on.
If you only have two minutes, here is the short version. OpenAI said in August that it would wind down the contract supplying models to Cursor after SpaceX bought Cursor’s maker, Anysphere, for $60 billion. The proposed shutoff date is today, 12 November 2026, and no future OpenAI model — including GPT-6 Astra — will ever reach Cursor. Cursor’s chief executive says OpenAI models account for only about 5% of Cursor traffic, so most users will notice nothing. But if you are in that 5%, you need a plan, and this guide gives you one.

A developer works in a multi-monitor coding setup. For most Cursor users, the OpenAI Cursor cutoff changes nothing — but the 5% who rely on GPT models need a plan today.
Table of Contents
What the OpenAI Cursor cutoff means today
The OpenAI Cursor cutoff is the planned end of the commercial arrangement under which OpenAI supplies its language models to Cursor. From today, 12 November 2026, OpenAI’s proposed transition period expires. In plain terms, Cursor’s own supply of GPT models — the ones that appear in the model picker and are billed through your Cursor subscription — is scheduled to stop.
That matters because Cursor is not a small niche tool. It is one of the most widely used AI-first code editors in the world, with roughly two million active users and about $4 billion in annual recurring revenue by the middle of 2026. For two years it was the default way many developers met OpenAI’s models: you opened the editor, picked a GPT model, and the agent wrote, refactored and debugged code for you. The OpenAI Cursor cutoff breaks that default.
Three things are worth getting straight before we go further. First, the cutoff affects Cursor-supplied OpenAI access. It does not delete your OpenAI account, your ChatGPT subscription, or your OpenAI API key, and it does not stop OpenAI’s models from working anywhere else. Second, it does not affect the other model families in Cursor. Claude, Gemini, Grok and Cursor’s own Composer models all stay.
Third, and most importantly for today, the date is proposed rather than final. OpenAI’s own help page, updated for this week, says the company will “share the official termination date as soon as it is confirmed between both companies.” So today is the day the cutoff may take effect — not a day anyone has confirmed it has taken effect.
That distinction is not a technicality. It decides whether your GPT-powered workflow breaks this morning, keeps working for a few more days, or survives because the two companies reach a deal. The rest of this article treats the OpenAI Cursor cutoff as what it is: a dated, announced, still-negotiable break, with practical steps for every outcome.
How we got here: the $60 billion SpaceX deal
The story of the OpenAI Cursor cutoff starts with an acquisition, not with a product decision. In June 2026, SpaceX agreed to buy Anysphere, the San Francisco startup behind Cursor, for approximately $60 billion in an all-stock deal. The deal closed on 14 August 2026, making Cursor a wholly owned subsidiary of SpaceX — or, more precisely, of the SpaceXAI arm that now houses the former xAI business. Cursor’s co-founder and chief executive, Michael Truell, became a SpaceX executive in the process.
Two weeks after the deal closed, on 28 August 2026, OpenAI published a blog post titled “Our decision on Cursor following its acquisition by SpaceX.” In it, OpenAI said it would wind down the contract under which it supplies its models to Cursor, and proposed 12 November 2026 as the shutoff date — the maximum notice its contract allowed. It also said future models, including its upcoming GPT-6 Astra, would not be offered in Cursor at all.
Here is the timeline in full:
| Date | What happened |
|---|---|
| June 2026 | SpaceX agrees to acquire Anysphere (Cursor) for about $60 billion in stock |
| 14 August 2026 | The acquisition closes; Cursor becomes part of SpaceX |
| 28 August 2026 | OpenAI announces it will wind down its model-supply contract with Cursor |
| 28 August 2026 | Cursor CEO Michael Truell responds on X: OpenAI models are about 5% of Cursor traffic; talks continue |
| 29 August 2026 | Anthropic says it will keep increasing Claude compute for Cursor |
| October 2026 | OpenAI withholds new models from Cursor; GPT-6 and GPT-6.1 Sol/Terra never arrive |
| 9 November 2026 | Cursor adds Claude Fable 5.2 on its launch day, underlining the shift to other providers |
| 12 November 2026 | Today: OpenAI’s proposed shutoff date for Cursor’s direct model access |
The speed of the sequence is part of the story. OpenAI waited exactly two weeks after the acquisition closed before announcing the wind-down, and the proposed cutoff landed on the latest date the contract allowed. That is the behaviour of a company that had the legal machinery ready and was waiting for the deal to close before using it. It also explains why the OpenAI Cursor cutoff feels so abrupt to users: the commercial relationship ended in August, but the technical consequences were deferred until today.

Cursor’s model picker already stops at GPT-5.6. No GPT-6 model has ever shipped inside the editor since the SpaceX acquisition closed.
Why OpenAI is pulling its models from Cursor
OpenAI’s stated reason for the OpenAI Cursor cutoff is blunt, and it is worth quoting in full because the company has not softened it since August: “We cannot be confident that SpaceX will use our technology within our terms of service, based on our experience with Elon Musk’s companies violating contracts.”
That sentence carries a long history. OpenAI and Elon Musk have been in open conflict for years, across courtrooms, public statements and competing products. Musk co-founded OpenAI, left the board in 2018, and has since sued the company over its shift from non-profit to for-profit structure. OpenAI, for its part, has pointed to Musk’s companies breaking agreements — including X’s own breached OpenAI deal and what OpenAI describes as xAI violating its terms. The OpenAI Cursor cutoff is the latest round of that fight, and this time the leverage is a $60 billion coding tool with two million users.
There is also a commercial logic that has nothing to do with personalities. Cursor is now owned by SpaceX, whose AI arm, SpaceXAI, builds Grok — a direct competitor to OpenAI’s models. Supplying your best models to a competitor’s flagship product is a strange business, and OpenAI clearly decided it was not going to do it. The cutoff also protects OpenAI’s own developer push: the company is building Codex, its own coding agent, and would rather developers meet GPT models inside OpenAI’s own tools than inside a SpaceX-owned editor.
None of that makes the decision popular with the developers caught in the middle, and OpenAI acknowledged that in its August post, writing that it knew “the people most affected by this decision are the developers who rely on OpenAI models in Cursor.” The company’s answer to those developers is not to reverse the decision, but to offer the three workarounds covered later in this article: bring your own API key, use the Codex extension, or route through a gateway.
It is also worth noting what OpenAI did not say. It did not accuse Cursor itself of misusing its models, and it did not claim any technical or safety failure by Anysphere. The dispute is about ownership and trust between OpenAI and SpaceX, not about the editor’s quality. That distinction matters if you are deciding whether to stay with Cursor: the tool itself has not been criticised, only its owner has.
What exactly stops working after the OpenAI Cursor cutoff
The OpenAI Cursor cutoff sounds like a single event, but it actually switches off several different things at once. Here is each one, in the order you are most likely to feel it.
1. The GPT models leave the model picker
The most visible change is in Cursor’s model selector. Today, the OpenAI models in Cursor top out at the GPT-5.6 family — GPT-5.6 Sol, GPT-5.6 Terra and GPT-5.6 Luna — plus older GPT-5.x and Codex variants that are hidden by default. After the OpenAI Cursor cutoff, Cursor-supplied access to those models ends. They will disappear from the picker, and any saved configuration that points at them will stop resolving.
Note what has already happened here. OpenAI stopped shipping new models to Cursor the moment the wind-down began, which is why GPT-6, GPT-6.1 Sol and GPT-6.1 Terra never reached the editor. Cursor users have been frozen at GPT-5.6 for months while ChatGPT and Codex users moved on to GPT-6.1. Today’s cutoff finishes that process: the frozen catalogue goes away entirely.
2. Auto mode quietly changes underneath you
This is the change most people will miss, and it is arguably the most important. Cursor’s Auto mode picks a model for each request without telling you which one it chose. Some of those requests have quietly been running on GPT models. After the OpenAI Cursor cutoff, Auto will route those requests elsewhere — to Claude, Gemini, Grok or Composer — and your results may change without you touching a single setting.
If you have a workflow that depends on Auto behaving a particular way, check it this week. The same prompt can produce different code, different comments and different error-handling habits depending on which model answers it. A test suite that passed under GPT-5.6 may need a fresh look under Claude Sonnet 5.5 or Grok 4.7. That is not a reason to panic, but it is a reason to run your tests rather than assume nothing changed.
3. Cloud Agents, Background Agents and Automations lose GPT too
The cutoff is not limited to the editor window on your laptop. After the OpenAI Cursor cutoff, Cursor-supplied OpenAI access ends across the whole product, including Cloud Agents and Background Agents — the features that let agents work on your code while you are away from your desk. Automations built on GPT models stop as well. If you scheduled overnight work, code review or bug-hunting jobs that specify a GPT model, re-point them before they run.
Tab completion, by contrast, is unaffected in practice. Cursor Tab has always run on Cursor’s own models rather than on third-party ones, so your autocomplete experience should not change. The same is true of codebase indexing and embeddings, which run on Cursor’s infrastructure.
4. What stays: Claude, Gemini, Grok and Composer
Everything else in Cursor keeps working. Anthropic’s Claude models — including Opus 5.5, Sonnet 5.5 and the brand-new Claude Fable 5.2, which Cursor added on its 9 November launch day — remain available. Google’s Gemini models, including Gemini 3.1 Pro and Gemini 3.8 Flash, remain available. SpaceXAI’s Grok 4.7, 4.6 and 4.5 remain available, as does Cursor’s own Composer 2.5, which the company describes as its low-cost daily driver. Anthropic said within hours of OpenAI’s August announcement that it would keep increasing the Claude compute available inside Cursor, and it has done so ever since.
The practical upshot is that Cursor after the OpenAI Cursor cutoff is still a multi-model editor with frontier options — it is simply an editor without OpenAI in the picker. For the roughly 95% of traffic that never touched a GPT model, the product is unchanged.
What is still unconfirmed about the cutoff
Honest reporting requires saying plainly what we do not know yet, and there is a lot of it. The OpenAI Cursor cutoff is a proposed date, not a confirmed event, and several basic questions have no public answer as of this morning.
- Has the cutoff actually happened today? As of the latest public statements — updated on 11 November — neither company has said whether the models were still live on 11 November, and OpenAI’s help page says the official termination date will be shared “as soon as it is confirmed between both companies.” The date may hold, it may slip, or the two sides may settle. Do not treat any single report of “it happened” or “it didn’t” as final until OpenAI or Cursor confirms it.
- Could Cursor end access sooner? Yes. OpenAI’s own guidance notes that “Cursor may choose to end access sooner” than the proposed date. If you open Cursor and the GPT models are already gone, that is consistent with what OpenAI told users to expect.
- Will there be refunds or migration help? Nothing has been announced. It is not yet known what happens to Cursor users mid-subscription if OpenAI model access ends, whether any refunds will be offered, or whether Cursor will provide migration tooling. If you paid for a plan partly because of GPT access, keep your receipts and watch Cursor’s announcements.
- Could the two companies still reach a deal? Both sides have said talks are ongoing since August, and Truell has repeated that the companies are speaking to resolve the dispute. A last-minute agreement is possible, though nothing in the public record suggests one is close.
- What share of Cursor’s revenue depends on OpenAI models? Unknown. Truell’s 5% figure is about traffic, not revenue, and no one has published what share of paying customers chose Cursor specifically for GPT access.
The responsible way to read today’s news, then, is this: the OpenAI Cursor cutoff is the date OpenAI proposed, the technical groundwork for it is complete, and you should act as if it is happening — while remembering that the final word belongs to the two companies, not to the calendar.
The 5% figure: why most Cursor users will barely notice
The single most quoted number in this whole story is 5%. On the night of 28 August, Cursor’s Michael Truell posted that OpenAI models serve about 5% of Cursor user traffic. That number ended the panic for most people, and it has been repeated in almost every report since. It deserves a closer look, because it is both reassuring and misleading.
It is reassuring because it is probably true in broad terms. Cursor’s default model is its own Composer 2.5, and most users never change it. Claude has been the most popular third-party choice inside Cursor for a long time, and Gemini and Grok take most of the rest. For the overwhelming majority of the two million active users, the OpenAI Cursor cutoff removes a model they never selected. Their editor will look the same tomorrow as it did yesterday.
It is misleading because traffic is not the same as importance. The 5% who use GPT models in Cursor are not a random sample. They include teams that standardised on GPT-5.6 for a reason — because it handled their codebase well, because their prompts and rules were tuned for it, or because their compliance setup approved OpenAI and nothing else. A small share of traffic can still be a large share of the workflows that matter. One widely shared account this week described a developer auditing how much of his Claude Code setup would survive the cutoff and finding the answer was “most of it” — but the same audit for a GPT-centred setup would look very different.
There is a second reason to be careful with the 5% figure: it is a single number from one executive, given on the night the news broke, and it has not been independently verified or updated since. It measures traffic, not users, not requests that matter, and not revenue. Treat it as a useful guide to scale, not as a precise measurement of impact.
The fair summary is this. If you use Cursor’s default model, or Claude, or Gemini, or Grok, the OpenAI Cursor cutoff is a news story, not a work problem. If you use GPT models in Cursor — in the picker, in Auto mode, in Cloud Agents, or in Automations — it is a work problem, and the next section is for you.
How to keep using OpenAI models in Cursor: 3 official workarounds
OpenAI has published official guidance for developers who want to keep using its models inside Cursor after the OpenAI Cursor cutoff. There are three routes, and they are not equal. Each one covers a different part of the product, and each has limits you should understand before you commit to it.

OpenAI’s own help page lists three official routes to keep using its models in Cursor — but none of them covers the whole product.
Option 1: Bring your own OpenAI API key
The simplest route is to supply your own OpenAI API key. Cursor supports this in its local Chat and Agent features: requests are sent through your OpenAI API account and billed separately from your Cursor or ChatGPT subscription, at OpenAI’s API prices. Here is the setup, as OpenAI documents it:
- Create an OpenAI API key on the OpenAI platform. API access requires an OpenAI API account with billing configured — a ChatGPT subscription on its own does not include API usage.
- Open Cursor Settings, then select Models.
- Find the OpenAI API key setting, paste your key, and save or verify it.
- Enable the OpenAI model you want to use.
- Select that model in Cursor Chat or Agent.
The limits matter more than the setup. Your own key covers only local Chat and Agent requests in the desktop app. It does not apply to Cursor Tab and autocomplete, Auto model selection, Cloud or Background Agents, Automations, the Cursor CLI, or Cursor’s API and SDK. Those features use models supplied or routed by Cursor, and they cannot use your OpenAI key. Available models and usage limits depend on your OpenAI API organisation, and on individual plans your keyed requests do not draw on your plan’s included usage — they are billed directly by OpenAI.
There is also a privacy trade-off to know about. Your key is not stored on Cursor’s servers, but it is sent to Cursor’s backend with every request, because requests are routed through Cursor. Cursor’s Zero Data Retention policy does not apply to requests made with your own key; your provider’s privacy policy does instead. If your organisation has strict data-handling rules, check them before you paste a key in. And remember that Cursor’s own documentation describes the key as covering “standard, non-reasoning chat models” — so the newest reasoning-heavy models may not be available on this path at all.
For a solo developer who mostly works in local Chat and Agent, this is the best workaround. For a team running Cloud Agents or Automations, it is not a fix — those features simply cannot use your key.
Option 2: Use the Codex IDE extension inside Cursor
OpenAI’s second route is the Codex IDE extension, which runs Codex — OpenAI’s coding agent — directly inside Cursor as a separate extension. It does not depend on OpenAI models being available through Cursor’s own model picker, so the OpenAI Cursor cutoff does not touch it.
- Open the Codex IDE extension page and select Cursor to install the extension.
- Open Codex from the Activity Bar.
- Select Sign in with ChatGPT to use an eligible ChatGPT subscription, or select Use API Key to use an OpenAI API account.
- Open your project and start a task from the Codex panel.
The Codex extension provides its own agent experience inside the editor, and you can move its panel to the right side of the editor using Cursor’s layout controls. But be clear about what it does and does not do: it does not change the model used by Cursor Chat, Agent, Tab, Auto, Cloud Agents, or any other Cursor service. It is a second agent living in the same window, not a replacement for the GPT models in Cursor’s picker. If your workflow is “open Cursor, use the agent,” Codex gives you that with OpenAI’s newest models — including the GPT-6 family Cursor itself will never get. I
If your workflow is built on Cursor’s own agent features, Codex sits alongside them rather than inside them.
This is the strongest option if your real need is “OpenAI’s best coding models,” rather than “OpenAI’s models inside Cursor’s agent.” It also has a strategic advantage: Codex is where OpenAI is investing, so it will keep getting the newest models first.
Option 3: Route through an AI gateway provider
The third route is to connect Cursor to OpenAI models through a compatible AI gateway or hosting provider — for example, Amazon Bedrock, Azure, or another OpenAI-compatible gateway such as OpenRouter or the Vercel AI Gateway. This suits organisations that already manage model access and billing through a cloud provider.
- Provision the OpenAI model with your provider.
- Create the required credentials, endpoint, and model or deployment name.
- Open Cursor Settings, then select Models.
- Choose the provider integration, or configure the OpenAI API settings with the gateway’s custom base URL.
- Enter the endpoint and credentials supplied by your provider.
- Add or enable the corresponding model in Cursor.
- Test the model in a local Chat or Agent session.
Gateway compatibility varies, and a custom endpoint must support the API format Cursor expects. Some model-specific controls may not be available or forwarded through a custom base URL. And the same coverage limit applies as with your own key: gateway credentials cover only supported local Chat and Agent requests. They do not apply to Cursor Tab, Auto, Cloud or Background Agents, Automations, the Cursor CLI, or Cursor’s API and SDK.
For most individual developers, this is the most complex of the three routes, and it only makes sense if your organisation already runs on Bedrock or Azure. For everyone else, the API key or the Codex extension is simpler and faster.
One warning that applies to all three routes: OpenAI says its guidance is directional and that Cursor may change the functionality and availability of these features over time. Check Cursor’s official documentation for the latest position before you build a team workflow on any of them. The OpenAI Cursor cutoff is a moving situation, and the workarounds will move with it.
What to switch to instead of GPT in Cursor
If you would rather not fight to keep GPT inside Cursor, the honest news is that the alternatives are strong — in some cases stronger than the models you are losing. Cursor’s picker after the OpenAI Cursor cutoff still contains frontier models from three other labs, plus Cursor’s own. Here is how they compare for the jobs developers actually do.
| Model | Maker | Best for | Price per 1M tokens (input / output) |
|---|---|---|---|
| Composer 2.5 | Cursor | Everyday coding, fast edits, low cost | $0.50 / $2.50 |
| Grok 4.7 | SpaceXAI | General coding, long tasks | $2.00 / $6.00 |
| Claude Sonnet 5.5 | Anthropic | Careful refactors, long files, code review | $2.00 / $10.00 |
| Claude Opus 5.5 | Anthropic | Hardest problems, architecture, agents | $4.00 / $20.00 |
| Claude Fable 5.2 | Anthropic | Frontier agentic coding | $10.00 / $50.00 |
| Gemini 3.1 Pro | Huge codebases, multimodal work | $2.00 / $12.00 | |
| GPT-5.6 Sol (leaving) | OpenAI | — | $4.00 / $20.00 |
Prices are the API list prices Cursor charges for third-party models, as published in September–October 2026. Cursor’s own models are billed from a separate, more generous usage pool.
Claude: the natural first switch
For most GPT users in Cursor, Claude is the obvious first switch, and the market agrees. Claude Sonnet 5.5 is the workhorse: strong at reading large files, careful with refactors, and notably good at explaining what it changed and why. Claude Opus 5.5 is the heavy option for the hardest problems, at the same $4/$20 price point GPT-5.6 Sol occupied.
And Claude Fable 5.2, added to Cursor on its 9 November launch day, is Anthropic’s newest frontier coding model. Anthropic has also committed to keep increasing the Claude compute available inside Cursor, which is the opposite of what is happening to OpenAI’s models. If your team standardised on GPT because it was the safe, well-documented choice, Claude is now the safe, well-documented choice — and it is the one with a future inside Cursor.
Gemini: the big-context option
Google’s Gemini 3.1 Pro is the switch to make if your problem is size. Gemini models are built for enormous context windows, which makes them good at jobs where the agent needs to hold a whole repository in mind — migrations, cross-service refactors, and audits of unfamiliar code. Gemini 3.8 Flash is the cheaper, faster sibling for routine work. Google’s models have been steadily improving as coding tools all year, and the OpenAI Cursor cutoff makes them worth a serious trial if you have never used them. Our earlier coverage of Gemini 4 Carbon explains where Google’s newest generation is heading, including the long-horizon work it is built for.
Grok and Composer: Cursor’s home team
Do not overlook the models Cursor itself supplies. Composer 2.5 is Cursor’s own model, built for speed and priced at $0.50 per million input tokens and $2.50 per million output tokens — a fraction of the frontier models. It is the cheapest way to do everyday coding in Cursor, and because it sits in the Cursor Models pool, paid plans include significantly more usage of it than of third-party models.
Grok 4.7, jointly developed by Cursor and SpaceXAI, is the flagship of that pool at $2/$6, and it is the model SpaceX most wants Cursor users to adopt. If you stay with Cursor long term, these are the models your subscription is actually built around, and the OpenAI Cursor cutoff is the moment to learn what they can do. Cursor’s new plans start at $8 a month for its own models, which makes the home team the cheapest entry point in the editor by a wide margin.
Leaving Cursor entirely: Claude Code, Codex and the open options
Some developers will decide that the cutoff is the moment to leave Cursor altogether, and there are credible places to go. Claude Code runs inside a Claude plan — Pro at $20 a month — and it is the same Claude models with a terminal-first agent experience. OpenAI’s Codex, available through ChatGPT or the API, is where GPT-6.1 Sol and Terra actually live, and it is the direct answer if your loyalty is to OpenAI’s models rather than to any one editor.
Windsurf, Zed and the open-source Cline and Kilo Code agents all accept your own API keys across providers, which makes them attractive if the lesson you take from the OpenAI Cursor cutoff is that no single vendor should own your whole workflow. Our guide to Meta’s Muse Spark Open covers another corner of the same shift: the big labs are all building open-weight models that run outside any one company’s editor, and that trend is accelerating.
Whichever switch you make, run the same test before you commit. Take a real task from your own backlog — a refactor you have been putting off, a bug you understand well — and run it through the new model. Compare the result with what GPT-5.6 gave you. A benchmark score is not a substitute for your own codebase.
Cursor pricing after the OpenAI Cursor cutoff
The OpenAI Cursor cutoff lands in the middle of a pricing overhaul, and the two stories are connected. Cursor has moved new customers onto The X Subscription — one subscription covering Grok, Cursor and X — while existing customers keep legacy plans. Here is the current picture.
| Plan | Price | What you get |
|---|---|---|
| Free | $0 | Limited Agent requests, access to Composer |
| Plus | $8/month | Cursor’s own models only; no third-party models, no bring-your-own key |
| Premium | $30/month | Cursor models plus third-party models at API list price; cloud agents, Bugbot reviews |
| Super | $100/month | Daily agent use; larger usage pools |
| Ultra | $200/month | Power users; 20x Pro limits, priority access to new features |
| Legacy Pro | $20/month | Existing subscribers keep it; roughly $20 of API-priced usage |
| Legacy Pro+ | $60/month | Existing subscribers keep it; 3x Pro agent limits |
Annual billing takes roughly 20% off the paid plans. Team plans start at $40 per user per month, with a Premium seat at $120.
Two things about this pricing matter for the cutoff. First, third-party models — Claude, GPT, Gemini — are billed at their API list price on top of the plan, from the Premium tier up. That means switching from GPT to Claude inside Cursor is largely a change of model, not a change of bill: Claude Sonnet 5.5 at $2/$10 per million tokens is actually cheaper than the GPT-5.6 Sol you are losing at $4/$20.
Second, Cursor’s own models are dramatically cheaper than any third-party option, and paid plans include far more usage of them. A developer who moves from GPT-5.6 to Composer 2.5 for routine work could cut model spend by roughly 90% on those tasks — which is one reason Cursor is relaxed about losing OpenAI. The economics of the editor now point towards its own models, and the OpenAI Cursor cutoff pushes users in that direction whether they planned to go there or not.
One more pricing wrinkle is worth knowing. On Teams and Enterprise plans, requests made with your own API key carry a Cursor Token Rate of $0.25 per million tokens on eligible models. On individual plans, keyed requests do not draw on the plan’s included usage at all — they are billed directly by the provider. Check which side of that line your plan sits on before you estimate costs.

Teams that standardised on GPT inside Cursor should re-point their agents and automations this week — the OpenAI Cursor cutoff reaches Cloud Agents and Automations too.
What teams and companies should do this week
Individual developers can switch models in an afternoon. Teams cannot, and the OpenAI Cursor cutoff is a team problem in ways that are easy to miss. Here is what engineering leads and managers should check before the end of the week.
Audit where GPT is actually used. Ask every team that uses Cursor which model their agents, rules and automations specify. The answer is often “Auto”, which means nobody knows — and that is exactly the configuration most exposed to the cutoff, because Auto may have been quietly routing work to GPT. A one-hour audit now is cheaper than a broken pipeline later.
Re-point Cloud Agents and Automations first. These are the features your own API key cannot rescue. A local Chat session can fall back to a keyed GPT model; a scheduled Cloud Agent cannot. If a nightly job, a code-review automation or a bug-triage workflow specifies GPT-5.6, change it to Claude Sonnet 5.5 or Grok 4.7 today, and run it once manually to confirm the output quality.
Decide the standard model, and write it down. The worst outcome of the OpenAI Cursor cutoff is not losing GPT — it is ten developers quietly picking ten different replacements and producing ten different code styles. Pick one default (Claude Sonnet 5.5 is the safest bet for most teams), document it in your Cursor rules, and let individuals deviate only with a reason.
Check compliance and data rules. If your organisation approved OpenAI and only OpenAI, switching to Claude or Gemini is not a technical decision — it is a procurement and legal one. And if you use the bring-your-own-key route, remember that Cursor’s Zero Data Retention policy does not apply to keyed requests. Get the approval before the migration, not after it.
Budget for the switch. The good news is that the switch is probably cheaper, not more expensive: Claude Sonnet 5.5 and Grok 4.7 both cost less per token than GPT-5.6 Sol. The bad news is that a new model may take more tokens to reach the same result while your team learns its habits. Budget for a month of higher usage, then measure the real number.
The bigger picture: coding tools are splitting into camps
The OpenAI Cursor cutoff is not really about one editor or one date. It is the clearest sign yet that AI coding tools are splitting into camps, and developers are being asked to choose one.
Until 2026, the coding-assistant market worked like a buffet. An editor like Cursor offered every lab’s models, and developers picked whichever was best that month. The labs competed on quality, and the editors competed on experience. That world is ending. OpenAI now wants you to use its models inside its own tools — ChatGPT and Codex. Anthropic wants you inside Claude Code. Google wants you inside Gemini and its Antigravity environment. SpaceX wants you inside Cursor, running Grok and Composer. Each camp is building a full stack: model, agent, editor, and billing, all under one roof.
There are good reasons for the split. A lab that controls the whole stack can tune the model for its own agent, ship features faster, and keep more of the revenue. But there is a cost, and developers are paying it: the freedom to mix and match is narrowing, and a commercial dispute between two companies can now remove a tool from your workflow overnight. The OpenAI Cursor cutoff is the first time a major model has been pulled from a major editor for ownership reasons rather than technical ones, and it will not be the last.
The counter-trend is worth watching too. Open-weight models are getting better every month — Meta’s Muse Spark Open, the Qwen family, and the newest open releases from the Chinese labs all run outside any one company’s editor. Tools like Zed, Cline and Kilo Code are built around the idea that your API keys are yours and your editor should not care which lab you pay. And OpenAI itself, even while cutting Cursor off, published three official workarounds that keep its models usable inside the editor — an acknowledgement that developers still expect portability, even in a world of camps.
Our recent coverage of Anthropic’s FlashProve touches the same theme from a different angle: as models become infrastructure, the question of which model answered you — and who controls it — is becoming a first-class concern, not a detail. The OpenAI Cursor cutoff is the commercial version of that question, and every developer will have to answer it for their own setup.
The practical advice that follows from all of this is simple. Do not build a workflow that only works with one provider’s models inside one provider’s editor. Keep your prompts, rules and evaluation tests portable. Use tools that accept your own keys. And treat any single-vendor setup as a risk to manage, not a convenience to enjoy. The developers who will be least affected by the next cutoff are the ones who learned the lesson from this one.
Your checklist for today
If you do nothing else after reading this article, do these six things before you close it:
- Open Cursor and check your model picker. Are GPT models still listed? If they are gone, the OpenAI Cursor cutoff has taken effect for you. If they are still there, remember the date is proposed and the position may change.
- Check Auto mode. If you use Auto, run your test suite after switching the default to Claude Sonnet 5.5 or Grok 4.7, and compare the results with your last GPT run.
- Re-point Cloud Agents and Automations. Anything scheduled that specifies a GPT model needs a new model today — your API key will not save these.
- Decide your workaround, if you need one. Bring your own API key for local Chat and Agent, the Codex extension for OpenAI’s newest models, or a gateway if your organisation already uses one. Do not assume one workaround covers everything — each has limits.
- Pick your replacement model and test it on real work. Claude Sonnet 5.5 for careful work, Grok 4.7 or Composer 2.5 for speed and cost, Gemini 3.1 Pro for huge codebases.
- Watch for confirmation. Check OpenAI’s help page and Cursor’s announcements for the official termination date. Until one of them confirms it, treat every report as provisional.
OpenAI Cursor cutoff FAQ
When is the OpenAI Cursor cutoff?
OpenAI proposed 12 November 2026 as the date its contract supplying models to Cursor would end. That is today. But the date is a proposal, not a confirmed termination: OpenAI says it will share the official termination date as soon as it is confirmed between both companies, and talks were still ongoing as of 11 November. The OpenAI Cursor cutoff may take effect today, may slip, or may be resolved by agreement.
Which models are leaving Cursor?
The GPT models supplied through Cursor: the GPT-5.6 family (Sol, Terra and Luna) and older GPT-5.x and Codex variants. No GPT-6 model ever reached Cursor, and GPT-6.1 Sol and Terra will not either. Claude, Gemini, Grok and Composer models are unaffected.
Can I still use OpenAI models in Cursor after the cutoff?
Yes, in limited ways. You can bring your own OpenAI API key for local Chat and Agent requests, use the Codex IDE extension for a separate Codex agent inside Cursor, or route through an AI gateway such as Bedrock or Azure. None of these covers Cursor Tab, Auto, Cloud or Background Agents, Automations, the CLI, or the API and SDK. Full details are in the OpenAI help article on using OpenAI models in Cursor.
Does my ChatGPT subscription help?
Only through the Codex extension, where you can sign in with an eligible ChatGPT subscription. A ChatGPT subscription does not include OpenAI API usage, so it does not pay for bring-your-own-key requests — those are billed through your separate OpenAI API account.
What should I switch to in Cursor?
Claude Sonnet 5.5 is the safest general replacement, and it costs less per token than GPT-5.6 Sol. Claude Opus 5.5 matches it for the hardest work. Grok 4.7 and Composer 2.5 are the cheapest options and sit in Cursor’s own usage pool. Gemini 3.1 Pro is the best choice for very large codebases. Test your replacement on a real task from your own backlog before you commit.
Will Cursor refund me if I paid for GPT access?
Nothing has been announced about refunds or migration help. It is not yet known what happens to Cursor users mid-subscription if OpenAI model access ends. If you paid for a plan partly because of GPT access, keep your receipts and watch Cursor’s announcements.
Is Cursor still worth using after the OpenAI Cursor cutoff?
For most users, yes — Cursor still offers Claude, Gemini, Grok and its own Composer models, and about 95% of its traffic never touched a GPT model. Whether it is worth it for you depends on how much of your workflow ran on GPT, and whether the workarounds or the alternatives above cover it. If your loyalty is to OpenAI’s models specifically, Codex or Claude Code may now be a better home.

The OpenAI Cursor cutoff is the first time a major model has been pulled from a major editor over ownership — and it will not be the last. Portable prompts and your own API keys are the insurance.
The bottom line
The OpenAI Cursor cutoff is a strange kind of deadline: dated today, announced in August, and still not fully confirmed. What is certain is the direction of travel. OpenAI and SpaceX are no longer partners, GPT models are leaving Cursor’s picker, and no future OpenAI model will arrive there. What is uncertain is only the exact hour it happens and whether a last-minute deal changes anything.
For most Cursor users, today will feel like any other day. Their default model is Composer, or Claude, or Gemini, and none of those is going anywhere. For the developers in the 5% who built their workflow on GPT inside Cursor, today is the day to act: check the picker, re-point the automations, pick a replacement, and test it on real work. The three official workarounds exist for a reason — use them if they fit, and move on if they do not.
The larger lesson is the one the whole industry is learning at the same time. AI coding tools are becoming camps, and a camp can close its gates. The developers who stay flexible — portable prompts, their own keys, tests that run against any model — will be the ones who keep shipping whatever happens next. Today is a good day to become one of them.
