HTTP Status Codes

Web

Reference for HTTP status codes (1xx-5xx) with meanings, examples and use cases. Debug API responses faster by looking up 404, 503 and every other code.

80 codes
100Informational
Continue
Interim response to a request carrying Expect: 100-continue — the client should now send the body. A server that rejects the headers can answer 417 instead, saving the upload.
RFC 9110 §15.2.1
101Informational
Switching Protocols
Server accepts the Upgrade request and switches to the named protocol (most often websocket). After this line, the connection stops speaking HTTP.
RFC 9110 §15.2.2
102Informational
Processing
WebDAV: the server has accepted the whole request and is still working, sent to stop clients from timing out on long operations.
RFC 2518
103Informational
Early Hints
Lets the server send Link headers before the final response, so the browser can start preloading CSS/JS while the origin is still rendering the page.
RFC 8297
104TemporaryInformational
Upload Resumption Supported
Temporary registration expiring 2026-11-13. Signals that an interrupted upload can be resumed from an offset instead of restarted.
draft-ietf-httpbis-resumable-upload-05
200Success
OK
The default success answer. Its meaning depends on the method: GET returned the representation, PUT replaced it, POST returned the result.
RFC 9110 §15.3.1
201Success
Created
A new resource now exists. The Location header must point at it — if your API returns 201 without Location, clients cannot find what they just made.
RFC 9110 §15.3.2
202Success
Accepted
Queued for later processing; the work has not happened yet. Return a handle (job id or status URL) so the client can poll.
RFC 9110 §15.3.3
203Success
Non-Authoritative Information
The payload came from a transforming proxy, not the origin — for example an HTML-rewriting CDN. Rarely the right code unless you operate such a proxy.
RFC 9110 §15.3.4
204Success
No Content
Success with deliberately empty body — typical for DELETE or a form POST that redirects itself in JS. Do not pair with a body; some clients choke on the mismatch.
RFC 9110 §15.3.5
205Success
Reset Content
Tells the client to clear the submitted form. Browsers largely ignore it today, so reset the fields yourself.
RFC 9110 §15.3.6
206Success
Partial Content
Answer to a Range request. The Content-Range header tells the client which bytes it got; without it, players and resumable downloads break.
RFC 9110 §15.3.7
207Success
Multi-Status
WebDAV: one request touched several resources, so the XML body carries a separate status per resource.
RFC 4918
208Success
Already Reported
WebDAV: this resource was already listed inside a 207 earlier in the same response, so it is skipped to avoid loops in deep collections.
RFC 5842
226Success
IM Used
Body is a set of delta patches rather than a full record. Only appears with the A-IM header; almost no mainstream server implements it.
RFC 3229
300Redirect
Multiple Choices
Several representations exist and the server will not choose. In practice clients rarely know what to do with it; prefer 302 with a clear target.
RFC 9110 §15.4.1
301Redirect
Moved Permanently
Permanent move that browsers and CDNs cache indefinitely. Only use when you will never serve the old URL again — a mistaken 301 is painful to undo because caches keep honouring it.
RFC 9110 §15.4.2
302Redirect
Found
Temporary redirect, not cached. Note the historical trap: most clients turn a POST into a GET here, which is why 307 exists.
RFC 9110 §15.4.3
303Redirect
See Other
Explicitly says "fetch the result with GET at this URL" — the correct answer after a successful POST when you want a redirect instead of a 201.
RFC 9110 §15.4.4
304Redirect
Not Modified
Conditional GET hit: the client cache is still valid, send no body. Must accompany ETag or Last-Modified, otherwise the next request has nothing to revalidate against.
RFC 9110 §15.4.5
305Redirect
Use Proxy
Deprecated for security reasons; RFC 9110 says clients must not follow it. Listed for completeness only.
RFC 9110 §15.4.6
306UnusedRedirect
(Unused)
Reserved and never assigned. It was briefly "Switch Proxy" in an old draft and the number has been left unused since.
RFC 9110 §15.4.7
307Redirect
Temporary Redirect
Like 302 but the method and body must be preserved, so a POST stays a POST. Use this for temporary moves of form or API endpoints.
RFC 9110 §15.4.8
308Redirect
Permanent Redirect
Like 301 but method-preserving. The safer choice for moving an API base URL, since clients will not silently downgrade POST to GET.
RFC 9110 §15.4.9
400Client error
Bad Request
The request is malformed — bad JSON, missing required field, wrong type. Include what failed in the body; a bare 400 leaves the caller guessing.
RFC 9110 §15.5.1
401Client error
Unauthorized
No credentials, or they are invalid. Despite the name it means unauthenticated, not unauthorised — that is 403. Must include a WWW-Authenticate header.
RFC 9110 §15.5.2
402Client error
Payment Required
Long reserved for future use and still officially unused by HTTP, though APIs repurpose it for quota exhausted. If you use it that way, document it.
RFC 9110 §15.5.3
403Client error
Forbidden
Credentials are fine but this identity may not do this. Re-authenticating will not help — that is the difference from 401.
RFC 9110 §15.5.4
404Client error
Not Found
No resource at that URL — and deliberately no hint whether it ever existed. Returning 404 for "exists but not yours" is a common way to avoid leaking IDs.
RFC 9110 §15.5.5
405Client error
Method Not Allowed
The URL exists but not for this method. You must send an Allow header listing what does work — it is the whole point of choosing 405 over 404.
RFC 9110 §15.5.6
406Client error
Not Acceptable
Content negotiation failed: nothing the server can produce matches the Accept header. Usually means your API only emits JSON but the client asked for XML.
RFC 9110 §15.5.7
407Client error
Proxy Authentication Required
The proxy in front demands credentials, not the origin. The challenge comes via Proxy-Authenticate, which is separate from WWW-Authenticate.
RFC 9110 §15.5.8
408Client error
Request Timeout
The server gave up waiting for the request. On an idle keep-alive connection this is routine; mid-upload it means the client stalled.
RFC 9110 §15.5.9
409Client error
Conflict
The request clashes with current server state — duplicate unique key, optimistic-lock version mismatch, edit conflict. Usually retryable after re-reading state.
RFC 9110 §15.5.10
410Client error
Gone
Was here, is gone for good, and you should drop it from your index. Search engines treat 410 faster than 404 for removal.
RFC 9110 §15.5.11
411Client error
Length Required
The server refuses chunked or unknown-length bodies and wants Content-Length. Mostly seen from old proxies.
RFC 9110 §15.5.12
412Client error
Precondition Failed
If-Match or If-Unmodified-Since did not hold — someone else changed the resource. This is how you implement lost-update protection.
RFC 9110 §15.5.13
413Client error
Content Too Large
Body exceeds the server limit. RFC 9110 dropped the old "Request Entity Too Large" wording; the fix is raising the limit or streaming the upload.
RFC 9110 §15.5.14
414Client error
URI Too Long
The URL exceeded the server limit. Almost always a GET carrying data it should have sent in a POST body.
RFC 9110 §15.5.15
415Client error
Unsupported Media Type
The Content-Type is not one this endpoint accepts — typically a POST without Content-Type: application/json. Check the header, not the body.
RFC 9110 §15.5.16
416Client error
Range Not Satisfiable
The requested byte range lies outside the resource. Respond with Content-Range: bytes */<size> so the client can recover.
RFC 9110 §15.5.17
417Client error
Expectation Failed
The Expect header asked for something the server cannot do. This is the intended reply to an unacceptable Expect: 100-continue.
RFC 9110 §15.5.18
418UnusedClient error
(Unused)
IANA lists 418 as unused and RFC 9110 reserves it without defining behaviour. The famous teapot joke comes from RFC 2324, an April Fools spec. Safe to keep returning it for fun, but nothing standard will react.
RFC 9110 §15.5.19
421Client error
Misdirected Request
The connection was reused for a host it was not authorised for — a TLS session for a.com receiving a request for b.com. Clients should retry on a fresh connection.
RFC 9110 §15.5.20
422Client error
Unprocessable Content
Syntax is valid but the values are semantically wrong — a date field holding "yesterday". RFC 9110 renamed this from "Unprocessable Entity"; both names are still in wide use.
RFC 9110 §15.5.21
423Client error
Locked
WebDAV: the resource is locked by another principal, so the edit is refused until the lock is released.
RFC 4918
424Client error
Failed Dependency
WebDAV: this action failed because a different action it depended on failed. Reports the real cause instead of a misleading success.
RFC 4918
425Client error
Too Early
Refuses a replayable early-data request to prevent replay attacks. The client should resend after the TLS handshake completes.
RFC 8470
426Client error
Upgrade Required
The client must switch protocols (usually to TLS) before continuing. Send an Upgrade header saying what is required.
RFC 9110 §15.5.22
428Client error
Precondition Required
The origin refuses unconditional writes to stop lost updates — the client must send If-Match. Pair it with 412 for the mismatch case.
RFC 6585
429Client error
Too Many Requests
Rate limited. Read Retry-After — it gives the exact seconds to wait; retrying sooner just extends the window.
RFC 6585
431Client error
Request Header Fields Too Large
Header block exceeded the limit, usually from oversized cookies or a JWT stuffed into a header. Trim the cookie scope rather than raising the limit.
RFC 6585
451Client error
Unavailable For Legal Reasons
Blocked by legal demand, not by the operator's choice. The response should link to the demand or a policy page so the block is auditable.
RFC 7725
500Server error
Internal Server Error
Something broke on the server and no more specific code fits. Log a correlation id and return it in the body — without it, support cannot find the request.
RFC 9110 §15.6.1
501Server error
Not Implemented
The server does not recognise the method at all, as opposed to 405 where it knows the method but not for this URL.
RFC 9110 §15.6.2
502Server error
Bad Gateway
A proxy or gateway got an unusable answer from upstream — connection refused, or a response that failed to parse. The fault is upstream, not in the proxy.
RFC 9110 §15.6.3
503Server error
Service Unavailable
Overloaded or in maintenance. Unlike 500 this is expected to clear, so send Retry-After and clients will back off instead of hammering you.
RFC 9110 §15.6.4
504Server error
Gateway Timeout
Upstream did not answer in time. Nearly always a slow origin or a timeout set too low in the proxy — check both before touching the client.
RFC 9110 §15.6.5
505Server error
HTTP Version Not Supported
The server refuses this HTTP version. Common when a client speaks HTTP/2 cleartext (h2c) to a server that only accepts HTTP/1.1.
RFC 9110 §15.6.6
506Server error
Variant Also Negotiates
Transparent content negotiation is misconfigured: the negotiated variant points at another negotiation, looping. A server config bug.
RFC 2295
507Server error
Insufficient Storage
WebDAV: the server cannot store the representation — disk or quota full. It is the WebDAV equivalent of ENOSPC.
RFC 4918
508Server error
Loop Detected
WebDAV: the server hit an infinite loop while processing depth, usually from a collection that contains itself.
RFC 5842
510ObsoleteServer error
Not Extended
Obsoleted along with the HTTP Extension Framework it belonged to. Do not implement it in new code.
RFC 2774 (Deprecated)
511Server error
Network Authentication Required
You are behind a captive portal — hotel or airport Wi-Fi that wants a login page before letting traffic through.
RFC 6585
419frameworkClient error
Page Expired
Laravel uses this for a failed CSRF token check, so it behaves like a 403. Not an IANA code; you only see it on Laravel apps.
Laravel
444nginxClient error
No Response
nginx closes the connection without sending anything — used to drop malicious or abusive requests silently.
nginx
449msClient error
Retry With
IIS asks the client to retry after supplying more information. Microsoft-specific and never standardised.
Microsoft IIS
494nginxClient error
Request Header Too Large
nginx rejects an oversized header block before the request reaches your app — the fix belongs in nginx config, not application code.
nginx
495nginxClient error
SSL Certificate Error
nginx saw a client certificate it could not verify. Only appears when mutual TLS is enabled.
nginx
496nginxClient error
SSL Certificate Required
nginx requires a client certificate and none was presented — usually a missing or mis-scoped browser certificate.
nginx
497nginxClient error
HTTP Request Sent to HTTPS Port
Plain HTTP arrived on a TLS port. Almost always a client configured with the wrong scheme, not a certificate problem.
nginx
499nginxClient error
Client Closed Request
The client hung up before nginx finished responding. In logs it usually means your upstream is too slow — the user gave up.
nginx
509otherServer error
Bandwidth Limit Exceeded
Shared-hosting convention for an exceeded monthly transfer quota. Not part of HTTP.
cPanel / Apache
520cloudflareServer error
Unknown Error
Cloudflare got an empty or unexpected response from your origin. Check the origin server log, not Cloudflare.
Cloudflare
521cloudflareServer error
Web Server Is Down
Cloudflare could not connect at all — the origin refused the connection or the process is not running.
Cloudflare
522cloudflareServer error
Connection Timed Out
The TCP handshake to the origin never completed — often a firewall dropping packets silently rather than rejecting them.
Cloudflare
523cloudflareServer error
Origin Is Unreachable
No route to the origin at all — typically a DNS or network misconfiguration on the origin side.
Cloudflare
524cloudflareServer error
A Timeout Occurred
Connection succeeded but the origin did not finish responding in time. This is the slow-backend case, distinct from 522.
Cloudflare
525cloudflareServer error
SSL Handshake Failed
The TLS handshake with the origin failed — usually a cipher or protocol version mismatch on the origin.
Cloudflare
526cloudflareServer error
Invalid SSL Certificate
Cloudflare could not validate the origin certificate — expired, self-signed, or wrong hostname.
Cloudflare
IANA HTTP Status Code Registry · 80 codes · 2026-10-2716 of these are not IANA-registered — they come from specific servers: nginx, Cloudflare, IIS, Laravel, cPanel

About HTTP Status Codes

HTTP status codes are the three-digit results a server returns for each request, grouped by their first digit into five classes: 1xx informational, 2xx success, 3xx redirection, 4xx client error, and 5xx server error. This tool ships a complete code dictionary: enter codes like 404, 301, or 429 to find the standard name, meaning, class, and common use cases, or search by keyword such as "redirect" or "unauthorized".The tables are bundled in the page and queried entirely in your browser, with no network requests. The first digit sets the response class, and understanding that is more practical than memorising numbers. Informational means the request was received but not finished, success that it was handled correctly, redirection that the client must request elsewhere, client error that the request itself is at fault, and server error that the request was fine but handling failed. For an unfamiliar code, the first digit says who fixes it. Returning errors inside a success code is the most common misuse and breaks every upstream that depends on the status. Some interfaces return success on a business failure and put an error flag in the body, defeating monitoring, caching and retry policy, which read only the status. Use a code matching the semantics and put details in the body. Choosing temporary versus permanent redirects affects clients and search engines, and confusing them causes lasting problems. A permanent redirect is cached long term, so a misconfiguration persists in clients even after it is corrected, while a temporary one leaves no such cache. Use the temporary code when the intent is a temporary adjustment. Gateway-related codes quickly localise a fault, valuable when troubleshooting production. They appear when a request passed the gateway but the upstream responded late or abnormally, so seeing one places the problem after the gateway rather than at the client, while a client error code means the request never reached business logic. That halves the search space immediately. Cache-related codes differ strictly in meaning and misusing them shows users stale content. One requires the client to revalidate conditionally on later requests, another merely reports the content as unchanged without retransmission, and a third signals a resource permanently removed. Configure caching and retirement by semantics rather than one code for everything. Finally, keep the status code and the response body consistent so a client can handle both with one logic. If some interfaces return structured fields on error and others plain text, the client writes per-interface parsing and misses cases. Agree one error shape paired with the codes — a low-cost convention in interface design with clear returns.

How It Works Internally

Status codes fall into five classes by leading digit, each saying how far the request got: informational, success, redirection, client error, server error. The crucial split is transport versus business — returning a success code for a business failure forces clients to parse the body and deprives monitoring of a reliable signal. Permanent and temporary redirects are also not interchangeable, since the former is cached long term.

InputReturning 200 with {ok:false} for a missing resource
OutputMonitoring sees no error rate, caches may store the failure and clients must parse the body — 404 is correct

Measured on This Page

Entries80 = 64 IANA-registered + 16 vendor extensions
Name accuracyAll 64 IANA entries match the 2026-10-27 registry; 422 was officially renamed from Unprocessable Entity to Unprocessable Content
Registry status2 unused (306, 418) · 1 obsolete (510) · 1 temporary (104)
Vendor splitnginx 6 / Cloudflare 7 / IIS 1 / Laravel 1 / cPanel 1

IANA lists 418 under the official name (Unused): RFC 9110 §15.5.19 reserves the number without defining any behaviour. The teapot joke comes from the April Fools RFC 2324 and was never a real registration. Separately, 104 (upload resumption) is a temporary registration that expires on 2026-11-13 and will fall back into the unassigned range.

How this was measured: Compared every entry against the IANA HTTP Status Code Registry (http-status-codes-1.csv, fetched 2026-10-27), then verified the 16 non-IANA codes against the nginx, Cloudflare, Microsoft and Laravel documentation. The check is reproducible via scripts/audit/evidence/http_status_source.py, which reports missing codes, unknown sources and outdated names. · Measured 2026-10-27

How to Use

  1. Open "HTTP Status Codes"
  2. Type a code or keyword to filter the list
  3. Read the meaning, common causes and remediation
  4. Toggle "vendor-specific" to separate non-standard codes
  5. Check the 2xx to 5xx grouping for the right handling strategy

Use Cases

  • Debug API responses — Quickly confirm semantics of 422 or 409 to tell a data problem from a conflict.
  • Configure redirects — Distinguish 301 permanent from 302 temporary to avoid hurting SEO link equity.
  • Rate-limit design — Pick 429 Too Many Requests and pair it with a Retry-After header.
  • Error handling — Decide on the frontend whether to retry or prompt based on 4xx vs 5xx classes.
  • Learning & interviews — Systematically memorize standard definitions and applicable boundaries.
  • Proxy config — Check 502 vs 504 semantics to configure gateway timeout and retry logic correctly.
  • Cache tuning — Review 304 and 200 semantics to validate ETag-based caching and conditional requests.

FAQ

Difference between 301 and 308?

Both are permanent redirects, but with 301 a browser may switch POST to GET, while 308 strictly preserves the original method and body. Prefer 308 when form submissions are involved.

How to tell 401 from 403?

401 Unauthorized means not authenticated (missing or invalid credentials, go log in); 403 Forbidden means authenticated but lacking permission, where providing credentials again will not help.

When should I return 404 instead of 200?

Missing resources should return 404 so search engines and clients handle them correctly. Serving a "not found" page with 200 creates a soft 404 that harms indexing.

Is status code 418 real?

418 I'm a teapot comes from the April Fools' RFC 2324 joke and is not an official standard, though many frameworks keep it. Do not rely on it for business semantics in production.

What do 502, 503, and 504 mean?

502 means the gateway got an invalid upstream response, 503 means the service is temporarily unavailable (overload or maintenance), and 504 means the gateway timed out waiting upstream. Check the upstream service and timeout settings accordingly.

An API returns 200 for a business failure. Is that a misuse?

Yes, it conflates transport success with business outcome. A missing resource should be 404, invalid input 400 or 422, and unauthenticated versus unauthorized map to 401 and 403. Returning 200 for everything forces clients to parse the body to branch, and leaves monitoring and alerting without a reliable signal, which raises maintenance cost noticeably over time.

What goes wrong if 302 and 301 are mixed up?

301 means permanent, so browsers and intermediaries cache the redirect long term and may keep following it even after you restore the original address, while 302 means temporary and is not cached that way. Writing a temporary redirect as 301 is a common operational incident, especially during canary switches and domain migrations. Use a temporary code for anything likely to change, and upgrade to permanent only once it is settled.

What is the SEO difference between 301 and 302?

301 tells search engines the move is permanent and passes ranking to the new URL; 302 means temporary, so the old URL stays indexed. Writing a permanent redirect as 302 is a classic mistake that delays indexing of the new page.