Status Codes .

Standard response for successful HTTP requests. The actual response depends on the request method used. For a GET request, the response will contain an entity corresponding to the requested resource. For a POST request, the response will contain an entity describing or containing the result of the action.

The applicant requested the server to switch protocols, and the server agreed.

A WebDAV request may contain many sub-requests involving file operations, which requires a long time to complete the request. This code indicates that the server has received and is processing the request, but no response is available yet. This prevents the client from timing out and assuming that the request was lost. This status code is obsolete.

Used to return certain response headers before the final HTTP message

Standard response for successful HTTP requests. The actual response depends on the request method used. For a GET request, the response will contain an entity corresponding to the requested resource. For a POST request, the response will contain an entity describing or containing the result of the action.

The request was fulfilled, leading to the creation of a new resource.

The request has been accepted for processing, but processing has not been completed. The request may or may not ultimately be processed and may be prohibited during processing.

The server is a transforming proxy server (e.g., a web accelerator) that received a 200 OK from its origin, but returns a modified version of the origin’s response.

The server successfully processed the request and is not returning any content.

The server has successfully processed the request, asks the requester to refresh the document display, and does not return any content.

The server delivers only part of the resource (byte serving) due to the range header sent by the client. The range header is used by HTTP clients to enable interrupted downloads to be resumed or to split downloads into multiple concurrent streams.

The body of the message that follows is a standard XML message and may contain several separate response codes depending on how many partial requests were made.

The members of the DAV custody have already been named in the previous part (multi-part) of the answer and are not included again.

The server fulfilled the resource request, and the response is a representation of the result of one or more manipulations with instances that were used for the current instance.

Indicates multiple options for a resource that a client can choose from (via agent-driven content negotiation). This code could be used, for example, to present multiple video format options, to list files with different file name extensions, or to suggest word resolutions.

This and all future requests should be directed to the given URI.

It tells the client to look at a different URL (it was redirected to it). The HTTP/1.0 specification required the client to perform a temporary redirect using the same method (the original descriptive phrase was “Moved Temporarily”), but popular browsers implemented 302 redirects by changing the method to GET. Therefore, status codes 303 and 307 were added to HTTP/1.1 to distinguish between these two behaviors.

The response to the request can be found under a different URI using the GET method. When received as a response to POST (or PUT/DELETE), the client should assume that the server has accepted the data and should issue a new GET request to that URI.

Indicates that the resource has not been modified since the version specified in the If-Modified-Since or If-None-Match request headers. In this case, it is not necessary to resend the resource, as the client still has the previously downloaded copy available.

The requested resource is only available through a proxy server, whose address is specified in the response. For security reasons, many HTTP clients (such as Mozilla Firefox and Internet Explorer) do not comply with this status code.

No longer used. Originally meant “Subsequent requests should use the specified proxy server.”

In this case, the request should be repeated with a different URI; however, future requests should still use the original URI. Unlike how 302 has been historically implemented, changing the request method when repeating the original request is not allowed. For example, a POST request should be repeated using another POST request.

This and all future requests should be redirected to the given URI. 308 behaves similarly to 301, but does not allow changing the HTTP method. So, for example, submitting a form to a permanently redirected resource can proceed without any problems.

The server cannot or will not process the request due to an apparent client error (e.g., incorrect request syntax, excessive size, invalid request message framing, or misleading request routing).

Similar to 403 Forbidden, but specifically for use when authentication is required and has failed or has not yet been provided. The response must include a WWW-Authenticate header field containing a challenge applicable to the requested resource. See Basic Access Authentication and Digest Access Authentication. 401 semantically means “not authenticated”; the user does not have valid authentication credentials for the target resource.

Reserved for future use. The original intention was for this code to be used as part of some form of digital cash or micropayment scheme, as proposed by GNU Taler, for example, but this has not yet happened and the code is not commonly used. The Google Developers API uses this status if a particular developer has exceeded their daily request limit. Sipgate uses this code when an account does not have enough funds to initiate a call. Shopify uses this code when a store has not paid its fees and is temporarily disabled. Stripe uses this code for failed payments whose parameters were correct, such as blocked fraudulent payments.

The requested resource could not be found, but may be available in the future. Subsequent client requests are allowed.

The request method is not supported for the requested resource; for example, a GET request for a form that requires data to be submitted via POST, or a PUT request for a read-only resource.

The requested resource is only capable of generating content that is not acceptable according to the Accept headers sent in the request. See the section on Content Negotiation.

The client must first authenticate with the proxy server.

The server has timed out waiting for the request. According to HTTP specifications: “The client did not generate the request within the time the server was prepared to wait. The client MAY repeat the request without modification at any time later.”

Indicates that the request could not be processed due to a conflict in the current state of the resource, such as a conflict between multiple concurrent updates.

Indicates that the requested resource was previously available but is no longer available and will not be available again. This should be used when the resource has been deliberately removed and the resource should be cleaned up. Upon receiving status code 410, the client should not request the resource in the future. Clients, such as search engines, should remove the resource from their indexes. Most use cases do not require clients and search engines to delete the resource, and the “404 Not Found” code can be used instead.

The request did not specify the length of content required by the requested source.

The server does not meet one of the preconditions specified by the requester in the request header fields.

The request is larger than the server is willing or able to process. It used to be called “Request Entity Too Large.”

The provided URI was too long for the server to process. This is often the result of too much data being encoded as a query string in a GET request, in which case it should be converted to a POST request. Previously called “Request-URI Too Long”.

The request entity has a media type that the server or resource does not support. For example, the client uploaded an image as image/svg+xml, but the server requires images to use a different format.

This code was defined in 1998 as one of the IETF’s traditional April Fools’ jokes in RFC 2324, Hyper Text Coffee Pot Control Protocol, and is not intended to be implemented by real HTTP servers. The RFC states that this code should be returned by coffee pots that are asked to brew coffee. This HTTP status is used as an Easter egg on some websites, such as the “I’m a teapot” Easter egg on Google.com. Sometimes this status code is also used as a response to a blocked request instead of the more appropriate 403 Forbidden code.

The request was directed to a server that is unable to provide a response (for example, due to connection reuse).

The request was well-formed (i.e., syntactically correct), but could not be processed.

The resource being accessed is locked.

The request failed because it depended on another request, and that request failed (e.g., PROPPATCH).

Indicates that the server is unwilling to risk processing a request that could be played back.

The client should switch to another protocol, such as TLS/1.3, specified in the Upgrade header field.

The original server requires that the request be conditional. This is intended to prevent the “lost update” problem, where a client GETs the state of a resource, modifies it, and PUTs it back to the server, when in the meantime a third party has modified the state on the server, leading to a conflict.

The user has sent too many requests in a given time. Intended for use with rate limiting schemes.

The server is unwilling to process the request because either individual header fields or all header fields together are too large.

The server operator has received a legal request to deny access to the resource or to a file containing the requested resource. The code 451 was chosen as a reference to the novel Fahrenheit 451 (see acknowledgments in RFC).