DevOps / CI/CD

Claude 3.5 Sonnet Retired: How to Diagnose Cursor 429? (2026)

Claude 3.5 Sonnet Retired: How to Diagnose Cursor 429? (2026)

Anthropic lists Claude Sonnet 3.5 API retirement as effective October 28, 2025 in its model deprecation records. That changes how to interpret a Cursor 429: first identify which layer returned the response, then inspect its body, rate-limit headers, and gateway logs. A request still using the retired model ID is not fixed by adding retries.

This is for developers who see a Cursor error but don't know whether the request uses their own API key or a built-in service; engineers tracing LiteLLM gateway responses; and teams checking older Claude 3.5 Sonnet integrations.

Diagnose Claude 3.5 Sonnet API 429 errors by request path

HTTP 429 is a status code, not a complete diagnosis. It can indicate that a provider is limiting requests, but a gateway or another service in the path can also return a response with that status. A client may show the final error without exposing the original response from upstream. Treat the visible message as a starting point, not proof of which service is responsible.

The first useful question is therefore not “How many retries should be added?” It is “Which component sent the response that Cursor is showing?” The answer depends on the request path:

  • With a user-provided API key, Cursor sends requests using the configured provider credentials. The provider's response may be available in the client or relevant logs.
  • With a Cursor-managed model service, Cursor's service is part of the request path. You may see a client-facing error without access to the provider's raw response headers.
  • With a LiteLLM proxy, the gateway receives the client request and may apply its own controls before forwarding it. If it forwards the request, the provider can then return a separate response.

This distinction matters for ownership. A provider limit is not the same as an account or deployment limit imposed by a gateway. A client message also does not establish which of those occurred.

Start with a request trace, not a retry setting

Record the selected model, the configured key path, the time of the failure, and the exact error shown. If the request passes through a proxy, note its virtual key or deployment label using your internal logging policy. Avoid copying secret values into tickets or shared logs.

Then look for evidence at each boundary:

  • Client: Which model and provider are selected? Is the request configured to use a personal key, or a built-in service?
  • Gateway: Did LiteLLM accept the incoming request? Does its log show a local rejection, an upstream request, a retry, or a fallback?
  • Provider: If the request reached Anthropic, does the original response contain a provider error body or rate-limit headers?

A failure recorded before a gateway sends an upstream request cannot be diagnosed as an Anthropic rate limit from that request alone. Conversely, a gateway log showing an upstream response gives a concrete place to inspect provider evidence.

Cursor's own key versus its built-in model service

Cursor's API key settings documentation describes configuring provider keys in the client. Confirm the selected model and key path there before treating the displayed error as a provider-side failure. The configured path determines which service's account, limits, and support channel are relevant.

Request path Evidence you can usually inspect What the evidence can establish
Cursor configured with your provider API key Client configuration and, when exposed, the provider response Whether the request was configured to use your key, and whether a returned provider response includes rate-limit evidence
Cursor using a built-in model service Selected model and the message shown by Cursor What the client reports; without raw upstream details, not the provider's exact limit or account state
Cursor sending through LiteLLM Client configuration plus gateway logs and upstream response details, if recorded Whether the gateway rejected the request locally or forwarded it and received a provider response

The table is a boundary check, not a promise that every client exposes every header. If Cursor shows only a summarized error, don't infer a specific requests-per-minute limit, token allowance, or account cap from that summary. Ask the relevant service provider to confirm the account-side status.

When Cursor uses your own API key

Verify the provider key setting and the exact model selection. If you can inspect the raw response, preserve the status, response body, and relevant headers. A provider response that includes a retry-after value or rate-limit state is stronger evidence than a generic message rendered by the editor.

Keep credentials private when sharing diagnostics. Redact key values, authorization headers, and any request content that may contain source code or customer data. The useful information is usually the response metadata and the model identifier, not the secret used to authenticate.

A common misstep is to treat every Cursor 429 as a Cursor-wide outage. With a personal key, the request may be subject to the configured provider's limits or account controls. Check the actual path and provider response before changing client settings or contacting the wrong support team.

When Cursor uses a built-in model service

Confirm the selected model and whether the client is using a built-in service rather than a personal API key. Then preserve the exact message and the time it occurred. Check the service's displayed account or availability information, if provided.

There is an important evidence gap in this path. Without the raw upstream response, a client message cannot reliably reveal the provider's RPM, input-token, output-token, or account-level threshold. Those details should be confirmed with the service responsible for the request. Don't present a guessed provider quota as a diagnosis.

For a support request, include the selected model, the error text, the approximate time, and whether the issue repeats with the same configuration. Do not include API keys. This gives the service team information to investigate without turning an uncertain client message into a claim about Anthropic's limits.

Is Anthropic rate limiting the direct Cursor request?

Anthropic's API rate-limit documentation describes limits across dimensions such as requests per minute (RPM), input tokens per minute (ITPM), and output tokens per minute (OTPM). A response with HTTP 429 is consistent with rate limiting, but the response details and request path are needed to determine what happened.

When the request uses your Anthropic key and the original response is available, inspect the body and headers together. Anthropic documents retry-after and rate-limit response headers, including request and token limit, remaining, and reset information. These fields can help distinguish a rate-limit response from a generic client-side failure; see the provider's rate-limit reference and API error definitions.

How to read retry-after and rate-limit headers

Treat retry-after as an instruction associated with the response that actually contains it. Record the header value and the response source. A header forwarded by a proxy may reflect an upstream response; a header generated by a gateway may instead describe gateway behavior. The surrounding logs determine which interpretation fits.

Rate-limit headers provide context about the relevant limit dimension and its state. Compare the header family with the request that failed. For example, request-rate fields and token-rate fields point to different dimensions; they should not be collapsed into a single generic “API quota” explanation. If a response includes a reset value, retain it as returned rather than assuming that every limit resets on the same schedule.

A missing header is not proof that no limit was reached. The client may hide response headers, or an intermediary may not forward them. In that case, use the raw provider response if available, or ask the service owner to verify the request. Do not invent a threshold from the status code alone.

Anthropic also documents API errors by response type. Compare the actual response body with those definitions before labeling a failure as a rate limit. If the body instead indicates an invalid or unavailable model, changing the retry interval will not make that model valid.

Does 429 originate in LiteLLM?

A LiteLLM-based request has at least two boundaries to inspect: the client-to-gateway request and the gateway-to-provider request. LiteLLM's proxy architecture documentation describes the proxy request flow, while its user and rate-limit documentation covers gateway-side controls. Use those records to tell a local rejection from an upstream response.

Start with the gateway's inbound log for the failed request. Check whether the request was accepted, which model group or deployment was selected, and whether an upstream call appears. Then inspect any recorded upstream status, response body, retry, or fallback event. LiteLLM's Router documentation describes routing and retry behavior; here, the point is to identify what the existing configuration did, not to add a new fallback policy.

Gateway evidence Likely boundary to investigate Next check
A local rejection is logged and no upstream call is recorded Gateway key, user, team, deployment, or concurrency policy Verify the gateway rule and the identity associated with the request
An upstream request is recorded with a provider 429 response Provider-side rate or account limits, or a request that the provider rejected Inspect the upstream body and forwarded response headers
A retry or fallback event is recorded Router behavior and the result of the later attempt Match each attempt to its selected model and response source
Cursor reports 429 but the gateway has no matching request Client routing, another proxy, or a different request path Confirm the endpoint and actual model path used by the client

Do not assume that a gateway-generated 429 and a provider-generated 429 mean the same thing. A virtual key, team-level policy, or deployment concurrency setting may reject a request before it reaches Anthropic. If the gateway log records no upstream call, there is no evidence that Anthropic returned that particular 429.

When there is an upstream response, keep both records: the gateway's view and the provider response as received. If the gateway retries, a final client error may correspond to a later attempt rather than the first one. Without attempt-level context, the displayed message can conceal which model or provider produced the response.

Could a retired model ID look like rate limiting?

Yes, it can cause confusion if the client or gateway still names a retired model. Anthropic's retirement record identifies the Claude Sonnet 3.5 API retirement date as October 28, 2025. Check the exact model ID in the client selection, application configuration, and LiteLLM model mapping against the official retirement record.

Don't treat an unavailable or retired model error as a rate limit simply because a tool presents a shortened message or the request fails. Use the provider response body, where available, to distinguish an invalid or unavailable model from HTTP 429 rate-limit semantics. The Anthropic error documentation is the reference for interpreting provider error responses.

Search the active configuration rather than relying on a remembered setting. Check the model selected in Cursor, environment variables used by the application, the gateway's model aliases, and any deployment-specific mapping. A stale alias can keep generating requests for an old identifier even after a developer changes the visible client selection.

After switching to a currently supported model, make a controlled request and compare the resulting client message with the gateway and provider records. If the request now reaches a different model but still returns 429, investigate the new response on its own evidence. The model change does not prove that a separate limit was or was not active.

Choose the next action from evidence

Use these conditions to decide what to do next:

  • If the raw response is from Anthropic and includes rate-limit information, follow the response guidance and verify which limit dimension applies. Do not add retries that ignore retry-after.
  • If the gateway records a local rejection without an upstream request, inspect its virtual-key, user, team, or deployment policy. Changing the Anthropic API key will not correct a local gateway rule.
  • If the gateway records an upstream 429, inspect the provider response and its headers, then verify account status and rate-limit evidence with the provider as needed.
  • If no raw response headers are available, don't infer an exact quota from Cursor's display. Confirm the model path and seek the service owner's account-side diagnosis.
  • If a retired model ID remains in the configuration, correct the model mapping first. Re-test before adjusting retry behavior.
  • If no limit evidence appears and the model ID is current, check client routing, gateway logs, and account configuration before changing retry or fallback rules.

A retry can multiply traffic if each attempt produces another request. Cross-model fallback can also change the model that generates the response, so it does not guarantee identical output or behavior. These are reasons to use retry and routing logs as diagnostic evidence rather than treating more retries as a default remedy.

Finding Interpretation Action
Provider response carries rate-limit evidence The provider response is the relevant diagnostic record Follow its retry guidance and verify the affected limit dimension
Gateway rejects before forwarding The failure is local to the proxy path Review gateway identities, policy, and deployment configuration
Model ID matches the retired entry The request may not be reaching a currently supported model Update the model selection or mapping, then retest
Client shows only a generic 429 The response source is still unknown Trace the configured path and request the missing raw-response evidence

This sequence keeps the diagnosis tied to observable evidence: who returned the status, whether rate-limit headers are present, whether the gateway sent an upstream request, and whether the model ID is still valid. It avoids turning a single status code into an unsupported claim about provider quotas or account restrictions.

For a clean incident record, save the time, selected model, configured request path, sanitized response body, relevant response headers, and corresponding gateway event. Keep API keys out of logs and reports. If the records disagree—for example, the client shows a 429 but the gateway has no matching request—resolve the routing path before changing limits or retry settings.

The three tables above serve different decisions: identifying the request path, attributing a LiteLLM response, and choosing the next diagnostic action. None establishes an exact account quota without provider-side evidence. Anthropic's published limit dimensions explain what to inspect, but the applicable limits and request state must be determined from the response and account context.

A cloud Mac is not a fix for an Anthropic API rate limit. It also does not run model inference on behalf of the API provider. Its role is to provide a separate Mac development environment when the local machine is unavailable, shared, or unsuitable for the workflow. Compared with that setup, a developer's current local environment may depend on one machine remaining available, require the team to maintain its own access arrangements, and make it harder to separate development work from gateway operations. Renting a Mac can be a better fit for temporary development or environment testing, but not for sustained heavy workloads that justify owning hardware or jobs that require a physical interface.

If the issue is the development environment rather than the API response, review ProxyMac's service overview and its help information to assess whether a rented Mac fits that separate need. For a stable, long-running workload, a purchased Mac may be more appropriate; for an API 429, continue with the request-path evidence instead.

Run Your Development Workflow on a Dedicated Cloud Mac

Deploy your dedicated Apple Silicon M4 Mac with ProxyMac in about five minutes.
Connect to your cloud Mac from anywhere with SSH, VNC, or browser access.