Skip to content
← Newsroom
CloudWorldwide

Anthropic restores Claude.ai, Claude Code and Cowork after 40-minute authentication outage

A short outage where the API stayed up while logins failed is a clean lesson in shared dependencies and failure domains.

Square 1 AI Newsroom5 min read

Anthropic's consumer and developer products went down for a little over 40 minutes on Saturday evening US time, according to a report from BleepingComputer published on August 16. The incident began at roughly 21:58 UTC, when the company's status page said it was investigating a problem that stopped some users from authenticating to Claude.ai, Claude Code and Claude Cowork.

Within about ten minutes the scope widened. At 22:07 UTC Anthropic posted a second update describing degraded performance on Claude.ai and on platform.claude.com, the developer-facing site. Users reported failed logins, pages that would not load, requests that never completed and assorted error messages, BleepingComputer said. The Claude Console and the Claude API were listed as operational throughout, which meant that programmatic access through the API was not part of the reported disruption.

By 22:40 UTC the company confirmed that all affected services had been restored. At the time of BleepingComputer's report Anthropic had not published a root cause, and both the authentication issue and the broader degradation were still marked as under investigation on the status page. No figure for the number of affected users was given.

The episode is notable less for its length than for its shape: an authentication failure surfaced first, followed by a wider performance problem across web properties, while the API path stayed healthy. That pattern is a familiar one for anyone who has run a multi-product platform behind shared identity infrastructure, and it is the reason the incident is worth studying even though it was resolved quickly.

Why it matters

AI assistants are now embedded in daily developer workflows, so a login failure on a Saturday can stall coding sessions, agent runs and support work at once. The API staying up while the web products failed shows how much of a platform's reliability depends on its identity layer rather than the model. As more teams build on hosted models, incident timelines will be compared as closely as benchmark scores.

AI assistants are now embedded in daily developer workflows, so a login failure on a Saturday can stall coding sessions, agent runs and support work at once.

How an identity failure spreads across products
  1. Identity service degrades

    Sign-in requests slow down or return errors at the shared authentication layer.

  2. Every web product needs a fresh token

    Claude.ai, Claude Code and Cowork all depend on the same login path, so they fail together.

  3. Scope widens to performance

    Status page moves from an authentication issue to degraded performance on web properties.

  4. Separate path stays up

    The API and Console use a different route and remain operational throughout.

  5. Fix or rollback restores service

    All services confirmed restored about 40 minutes after the first update.

What you can learn from this

  • Authentication is a shared dependency. Most platforms route every sign-in through a single identity service that issues tokens the other products then trust. When that service slows down or returns errors, every product that needs a fresh token fails together, even if the underlying application servers are healthy. That is why an outage often appears first as "cannot log in" before anything else breaks, and why identity services deserve their own capacity planning, monitoring and on-call attention. Caching tokens on the client can mask a short blip but not a longer failure.

  • Status pages describe symptoms, not causes. A status page is updated by people under pressure, so early entries typically report what users see, such as authentication problems, rather than what engineers eventually find. The wording tends to broaden as the team learns more, which is exactly what happened when a login issue became degraded performance. Reading a status page well means treating each update as a snapshot in an unfolding investigation rather than a final explanation of what went wrong.

  • Separate paths fail separately. The API remained available while the web applications did not, which suggests those two paths depend on different components. Well-designed platforms deliberately isolate their surfaces so that a failure in one front door does not lock every door. For a learner, this is the concept of a failure domain: the set of things that go down together, which good architecture tries to keep as small as the business allows. Cloud providers apply the same idea when they place products in separate regions or accounts so that one misconfiguration cannot spread everywhere at once.

  • Recovery time is a design outcome. A roughly 40-minute incident implies that detection, diagnosis and a fix or rollback happened quickly. Teams achieve that through alerting on error rates rather than waiting for complaints, having a rollback path for every deployment and keeping runbooks that spell out who does what. The measure engineers use is mean time to recovery, and it is usually improved by rehearsal and clear ownership rather than by adding more hardware.

  • Postmortems close the loop. The absence of a root cause at the time of reporting is normal; a credible explanation takes days of log analysis and reconstruction. The industry norm is a blameless postmortem that lists the timeline, contributing factors and follow-up actions, because the goal is to prevent the same class of failure rather than to assign fault to a person. Vendors that publish these documents give customers a way to judge whether the fix addressed the cause.

How to use this in practice

  • Draw the failure domains of a service you use or build. Sketch the boxes: identity provider, web front end, API gateway, application servers, model or database backend. Draw an arrow for every dependency and then colour any box whose failure would take down more than one product. Done looks like a one-page diagram where you can point at the identity box and explain what stays up when it fails and what does not. Repeat the exercise for a second service and compare the two shapes.

  • Add a client-side retry with backoff to one call you make. Take a script that calls a hosted API and wrap the request in a loop that retries on 5xx or timeout errors, waiting one, two and four seconds between attempts with a little random jitter so that many clients do not retry in lockstep. Done looks like the script surviving a simulated failure (point it at an invalid host for the first attempt) and logging each retry with its wait time.

  • Subscribe to a vendor status feed and route it somewhere you will see it. Most status pages offer an RSS or webhook feed. Point that feed at a chat channel or your inbox and record the timestamp of the next incident you see, along with each update. Done looks like a saved entry with the start time, the updates and the resolution time, which you can compare against errors in your own logs to see how quickly you would have noticed on your own. Note also how long the vendor took to post its first update.

  • Write a five-line runbook for "the assistant is down". List the status URL, the alternative path (for example, direct API access with your own key or a locally hosted model), who to tell, what work to pause and how you will know it is over. Done looks like the runbook stored next to your other project notes and tested once by pretending the service is offline for fifteen minutes and following the steps exactly as written. Update it after every real incident you live through.

Sources

Our reporting is an original summary; full coverage is at the links above.

Don't just read about it — build it.

Square 1 teaches the skills behind the headlines, with every line of your work graded by AI. Find your starting point in 3 minutes.

Get your free skill report

More in Cloud