index.Status - Luke-zhang-04/utils GitHub Wiki

Enumeration: Status

index.Status

Hypertext Transfer Protocol (HTTP) response status codes

HTTP response status codes indicate whether a specific HTTP request has been successfully completed. Responses are grouped in five classes:

  1. Informational responses (100–199)
  2. Successful responses (200–299)
  3. Redirects (300–399)
  4. Client errors (400–499)
  5. Server errors (500–599)

Doc comments: copyright MDN Contributors under CC-BY-SA 2.5

Documentation from the MDN

See

https://developer.mozilla.org/en-US/docs/Web/HTTP/Status

Table of contents

Enumeration Members

Enumeration Members

Accepted

• Accepted = 202

202 Accepted

The HyperText Transfer Protocol (HTTP) 202 Accepted response status code indicates that the request has been accepted for processing, but the processing has not been completed; in fact, processing may not have started yet. The request might or might not eventually be acted upon, as it might be disallowed when processing actually takes place.

202 is non-committal, meaning that there is no way for the HTTP to later send an asynchronous response indicating the outcome of processing the request. It is intended for cases where another process or server handles the request, or for batch processing.

Documentation: copyright MDN Contributors under CC-BY-SA 2.5

See

https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/202

Defined in

http.ts:196

AlreadyReported

• AlreadyReported = 208

Already Reported

WebDAV

The members of a DAV binding have already been enumerated in a preceding part of the (multistatus) response, and are not being included again.

Defined in

http.ts:299

BadGateway

• BadGateway = 502

502 Bad Gateway

The HyperText Transfer Protocol (HTTP) 502 Bad Gateway server error response code indicates that the server, while acting as a gateway or proxy, received an invalid response from the upstream server.

Note: A Gateway might refer to different things in networking and a 502 error is usually not something you can fix, but requires a fix by the web server or the proxies you are trying to get access through.

Documentation: copyright MDN Contributors under CC-BY-SA 2.5

See

https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/502

Defined in

http.ts:1130

BadRequest

• BadRequest = 400

400 Bad Request

The HyperText Transfer Protocol (HTTP) 400 Bad Request response status code indicates that the server cannot or will not process the request due to something that is perceived to be a client error (for example, malformed request syntax, invalid request message framing, or deceptive request routing).

Warning: The client should not repeat this request without modification.

Documentation: copyright MDN Contributors under CC-BY-SA 2.5

See

https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/400

Defined in

http.ts:535

Conflict

• Conflict = 409

409 Conflict

The HTTP 409 Conflict response status code indicates a request conflict with the current state of the target resource.

Conflicts are most likely to occur in response to a PUT request. For example, you may get a 409 response when uploading a file that is older than the existing one on the server, resulting in a version control conflict.

Documentation: copyright MDN Contributors under CC-BY-SA 2.5

See

https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/409

Defined in

http.ts:729

ContentTooLarge

• ContentTooLarge = 413

413 Content Too Large

The HTTP 413 Content Too Large response status code indicates that the request entity is larger than limits defined by server; the server might close the connection or return a Retry-After header field.

Prior to RFC 9110 the response phrase for the status was Payload Too Large. That name is still widely used.

Documentation: copyright MDN Contributors under CC-BY-SA 2.5

See

https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/413

Defined in

http.ts:807

Continue

• Continue = 100

100 Continue

The HTTP 100 Continue informational status response code indicates that everything so far is OK and that the client should continue with the request or ignore it if it is already finished.

To have a server check the request's headers, a client must send Expect: 100-continue as a header in its initial request and receive a 100 Continue status code in response before sending the body.

Documentation: copyright MDN Contributors under CC-BY-SA 2.5

See

https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/100

Defined in

http.ts:58

Created

• Created = 201

201 Created

The HTTP 201 Created success status response code indicates that the request has succeeded and has led to the creation of a resource. The new resource, or a description and link to the new resource, is effectively created before the response is sent back and the newly created items are returned in the body of the message, located at either the URL of the request, or at the URL in the value of the Location header.

The common use case of this status code is as the result of a POST request.

Documentation: copyright MDN Contributors under CC-BY-SA 2.5

See

https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/201

Defined in

http.ts:176

EarlyHints

• EarlyHints = 103

103 Early Hints

The HTTP 103 Early Hints information response may be sent by a server while it is still preparing a response, with hints about the sites and resources that the server is expecting the final response will link. This allows a browser to preconnect to sites or start preloading resources even before the server has prepared and sent that final response.

The early hint response is primarily intended for use with the Link header, which indicates the resources to be loaded. It may also contain a Content-Security-Policy header that is enforced while processing the early hint.

A server might send multiple 103 responses, for example, following a redirect. Browsers only process the first early hint response, and this response must be discarded if the request results in a cross-origin redirect. Preloaded resources from the early hint are effectively pre-pended to the Document's head element, and then followed by the resources loaded in the final response.

Note: For compatibility reasons it is recommended to only send HTTP 103 Early Hints responses over HTTP/2 or later, unless the client is known to handle informational responses correctly.

Most browsers limit support to HTTP/2 or later for this reason. See browser compatibility below.

Despite this, the examples below use HTTP/1.1-style notation as per usual convention.

Documentation: copyright MDN Contributors under CC-BY-SA 2.5

See

https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/103

Defined in

http.ts:133

ExpectationFailed

• ExpectationFailed = 417

417 Expectation Failed

The HTTP 417 Expectation Failed client error response code indicates that the expectation given in the request's Expect header could not be met.

See the Expect header for more details.

Documentation: copyright MDN Contributors under CC-BY-SA 2.5

See

https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/417

Defined in

http.ts:885

FailedDependency

• FailedDependency = 424

Failed Dependency

WebDAV

The request failed due to failure of a previous request.

Defined in

http.ts:948

Forbidden

• Forbidden = 403

403 Forbidden

The HTTP 403 Forbidden response status code indicates that the server understands the request but refuses to authorize it.

This status is similar to 401, but for the 403 Forbidden status code, re-authenticating makes no difference. The access is tied to the application logic, such as insufficient rights to a resource.

Documentation: copyright MDN Contributors under CC-BY-SA 2.5

See

https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/403

Defined in

http.ts:602

Found

• Found = 302

302 Found

The HyperText Transfer Protocol (HTTP) 302 Found redirect status response code indicates that the resource requested has been temporarily moved to the URL given by the Location header. A browser redirects to this page but search engines don't update their links to the resource (in 'SEO-speak', it is said that the 'link-juice' is not sent to the new URL).

Even if the specification requires the method (and the body) not to be altered when the redirection is performed, not all user-agents conform here - you can still find this type of bugged software out there. It is therefore recommended to set the 302 code only as a response for GET or HEAD methods and to use 307 Temporary Redirect instead, as the method change is explicitly prohibited in that case.

In the cases where you want the method used to be changed to GET, use 303 See Other instead. This is useful when you want to give a response to a PUT method that is not the uploaded resource but a confirmation message such as: 'you successfully uploaded XYZ'.

Documentation: copyright MDN Contributors under CC-BY-SA 2.5

See

https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/302

Defined in

http.ts:384

GatewayTimeout

• GatewayTimeout = 504

504 Gateway Timeout

The HyperText Transfer Protocol (HTTP) 504 Gateway Timeout server error response code indicates that the server, while acting as a gateway or proxy, did not get a response in time from the upstream server that it needed in order to complete the request.

Note: A Gateway might refer to different things in networking and a 504 error is usually not something you can fix, but requires a fix by the web server or the proxies you are trying to get access through.

Documentation: copyright MDN Contributors under CC-BY-SA 2.5

See

https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/504

Defined in

http.ts:1175

Gone

• Gone = 410

410 Gone

The HyperText Transfer Protocol (HTTP) 410 Gone client error response code indicates that access to the target resource is no longer available at the origin server and that this condition is likely to be permanent.

If you don't know whether this condition is temporary or permanent, a 404 status code should be used instead.

Note: A 410 response is cacheable by default.

Documentation: copyright MDN Contributors under CC-BY-SA 2.5

See

https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/410

Defined in

http.ts:749

HTTPVersionNotSupported

• HTTPVersionNotSupported = 505

505 HTTP Version Not Supported

The HyperText Transfer Protocol (HTTP) 505 HTTP Version Not Supported response status code indicates that the HTTP version used in the request is not supported by the server.

Documentation: copyright MDN Contributors under CC-BY-SA 2.5

See

https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/505

Defined in

http.ts:1189

IMUsed

• IMUsed = 226

IM Used

HTTP Delta encoding

The server has fulfilled a GET request for the resource, and the response is a representation of the result of one or more instance-manipulations applied to the current instance.

Defined in

http.ts:310

ImATeapot

• ImATeapot = 418

418 I'm a teapot

The HTTP 418 I'm a teapot client error response code indicates that the server refuses to brew coffee because it is, permanently, a teapot. A combined coffee/tea pot that is temporarily out of coffee should instead return 503. This error is a reference to Hyper Text Coffee Pot Control Protocol defined in April Fools' jokes in 1998 and 2014.

Some websites use this response for requests they do not wish to handle, such as automated queries.

Documentation: copyright MDN Contributors under CC-BY-SA 2.5

See

https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/418

Defined in

http.ts:904

InsufficientStorage

• InsufficientStorage = 507

507 Insufficient Storage

The HyperText Transfer Protocol (HTTP) 507 Insufficient Storage response status code may be given in the context of the Web Distributed Authoring and Versioning (WebDAV) protocol (see RFC 4918).

It indicates that a method could not be performed because the server cannot store the representation needed to successfully complete the request.

Documentation: copyright MDN Contributors under CC-BY-SA 2.5

See

https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/507

Defined in

http.ts:1227

InternalError

• InternalError = 500

500 Internal Server Error

The HyperText Transfer Protocol (HTTP) 500 Internal Server Error server error response code indicates that the server encountered an unexpected condition that prevented it from fulfilling the request.

This error response is a generic "catch-all" response. Usually, this indicates the server cannot find a better 5xx error code to response. Sometimes, server administrators log error responses like the 500 status code with more details about the request to prevent the error from happening again in the future.

Documentation: copyright MDN Contributors under CC-BY-SA 2.5

See

https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/500

Defined in

http.ts:1061

InternalServerError

• InternalServerError = 500

500 Internal Server Error

The HyperText Transfer Protocol (HTTP) 500 Internal Server Error server error response code indicates that the server encountered an unexpected condition that prevented it from fulfilling the request.

This error response is a generic "catch-all" response. Usually, this indicates the server cannot find a better 5xx error code to response. Sometimes, server administrators log error responses like the 500 status code with more details about the request to prevent the error from happening again in the future.

Documentation: copyright MDN Contributors under CC-BY-SA 2.5

See

https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/500

Defined in

http.ts:1081

LengthRequired

• LengthRequired = 411

411 Length Required

The HyperText Transfer Protocol (HTTP) 411 Length Required client error response code indicates that the server refuses to accept the request without a defined Content-Length header.

Note: by specification, when sending data in a series of chunks, the Content-Length header is omitted and at the beginning of each chunk you need to add the length of the current chunk in hexadecimal format. See Transfer-Encoding for more details.

Documentation: copyright MDN Contributors under CC-BY-SA 2.5

See

https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/411

Defined in

http.ts:769

Locked

• Locked = 423

Locked

WebDAV

The resource that is being accessed is locked.

Defined in

http.ts:939

LoopDetected

• LoopDetected = 508

508 Loop Detected

The HyperText Transfer Protocol (HTTP) 508 Loop Detected response status code may be given in the context of the Web Distributed Authoring and Versioning (WebDAV) protocol.

It indicates that the server terminated an operation because it encountered an infinite loop while processing a request with "Depth: infinity". This status indicates that the entire operation failed.

Documentation: copyright MDN Contributors under CC-BY-SA 2.5

See

https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/508

Defined in

http.ts:1245

MethodNotAllowed

• MethodNotAllowed = 405

405 Method Not Allowed

The HyperText Transfer Protocol (HTTP) 405 Method Not Allowed response status code indicates that the server knows the request method, but the target resource doesn't support this method.

The server must generate an Allow header field in a 405 status code response. The field must contain a list of methods that the target resource currently supports.

Documentation: copyright MDN Contributors under CC-BY-SA 2.5

See

https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/405

Defined in

http.ts:639

MisdirectedRequest

• MisdirectedRequest = 421

Misdirected Request

The request was directed at a server that is not able to produce a response. This can be sent by a server that is not configured to produce responses for the combination of scheme and authority that are included in the request URI.

Defined in

http.ts:913

MovedPermanently

• MovedPermanently = 301

301 Moved Permanently

The HyperText Transfer Protocol (HTTP) 301 Moved Permanently redirect status response code indicates that the requested resource has been definitively moved to the URL given by the Location headers. A browser redirects to the new URL and search engines update their links to the resource.

Note: Although the specification requires the method and the body to remain unchanged when the redirection is performed, not all user-agents meet this requirement. Use the 301 code only as a response for GET or HEAD methods and use the 308 Permanent Redirect for POST methods instead, as the method change is explicitly prohibited with this status.

Documentation: copyright MDN Contributors under CC-BY-SA 2.5

See

https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/301

Defined in

http.ts:353

MultiStatus

• MultiStatus = 207

Multi-Status

WebDAV

The message body that follows is an XML message and can contain a number of separate response codes, depending on how many sub-requests were made.

Defined in

http.ts:289

MultipleChoices

• MultipleChoices = 300

300 Multiple Choices

The HTTP 300 Multiple Choices redirect status response code indicates that the request has more than one possible response. The user-agent or the user should choose one of them. As there is no standardized way of choosing one of the responses, this response code is very rarely used.

If the server has a preferred choice, it should generate a Location header.

Documentation: copyright MDN Contributors under CC-BY-SA 2.5

See

https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/300

Defined in

http.ts:329

NetworkAuthenticationRequired

• NetworkAuthenticationRequired = 511

511 Network Authentication Required

The HTTP 511 Network Authentication Required response status code indicates that the client needs to authenticate to gain network access.

This status is not generated by origin servers, but by intercepting proxies that control access to the network.

Network operators sometimes require some authentication, acceptance of terms, or other user interaction before granting access (for example in an internet café or at an airport). They often identify clients who have not done so using their Media Access Control (MAC) addresses.

Documentation: copyright MDN Contributors under CC-BY-SA 2.5

See

https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/511

Defined in

http.ts:1287

NoContent

• NoContent = 204

204 No Content

The HTTP 204 No Content success status response code indicates that a request has succeeded, but that the client doesn't need to navigate away from its current page.

This might be used, for example, when implementing "save and continue editing" functionality for a wiki site. In this case a PUT request would be used to save the page, and the 204 No Content response would be sent to indicate that the editor should not be replaced by some other page.

A 204 response is cacheable by default (an ETag header is included in such a response).

Documentation: copyright MDN Contributors under CC-BY-SA 2.5

See

https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/204

Defined in

http.ts:239

NonAuthoritativeInformation

• NonAuthoritativeInformation = 203

203 Non-Authoritative Information

The HTTP 203 Non-Authoritative Information response status indicates that the request was successful but the enclosed payload has been modified by a transforming proxy from that of the origin server's 200 (OK) response.

The 203 response is similar to the value 214, meaning Transformation Applied, of the Warning header code, which has the additional advantage of being applicable to responses with any status code.

Documentation: copyright MDN Contributors under CC-BY-SA 2.5

See

https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/203

Defined in

http.ts:217

NotAcceptable

• NotAcceptable = 406

406 Not Acceptable

The HyperText Transfer Protocol (HTTP) 406 Not Acceptable client error response code indicates that the server cannot produce a response matching the list of acceptable values defined in the request's proactive content negotiation headers, and that the server is unwilling to supply a default representation.

Proactive content negotiation headers include:

In practice, this error is very rarely used. Instead of responding using this error code, which would be cryptic for the end user and difficult to fix, servers ignore the relevant header and serve an actual page to the user. It is assumed that even if the user won't be completely happy, they will prefer this to an error code.

If a server returns such an error status, the body of the message should contain the list of the available representations of the resources, allowing the user to choose among them.

Documentation: copyright MDN Contributors under CC-BY-SA 2.5

See

https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/406

Defined in

http.ts:666

NotExtended

• NotExtended = 510

510 Not Extended

The HyperText Transfer Protocol (HTTP) 510 Not Extended response status code is sent in the context of the HTTP Extension Framework, defined in RFC 2774.

In that specification a client may send a request that contains an extension declaration, that describes the extension to be used. If the server receives such a request, but any described extensions are not supported for the request, then the server responds with the 510 status code.

Documentation: copyright MDN Contributors under CC-BY-SA 2.5

See

https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/510

Defined in

http.ts:1265

NotFound

• NotFound = 404

404 Not Found

The HTTP 404 Not Found response status code indicates that the server cannot find the requested resource. Links that lead to a 404 page are often called broken or dead links and can be subject to link rot.

A 404 status code only indicates that the resource is missing: not whether the absence is temporary or permanent. If a resource is permanently removed, use the 410 (Gone) status instead.

Documentation: copyright MDN Contributors under CC-BY-SA 2.5

See

https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/404

Defined in

http.ts:621

NotImplemented

• NotImplemented = 501

501 Not Implemented

The HyperText Transfer Protocol (HTTP) 501 Not Implemented server error response code means that the server does not support the functionality required to fulfill the request.

This status can also send a Retry-After header, telling the requester when to check back to see if the functionality is supported by then.

501 is the appropriate response when the server does not recognize the request method and is incapable of supporting it for any resource. The only methods that servers are required to support (and therefore that must not return 501) are GET and HEAD.

If the server does recognize the method, but intentionally does not support it, the appropriate response is 405 Method Not Allowed.

Note:

Documentation: copyright MDN Contributors under CC-BY-SA 2.5

See

https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/501

Defined in

http.ts:1110

NotModified

• NotModified = 304

304 Not Modified

The HTTP 304 Not Modified client redirection response code indicates that there is no need to retransmit the requested resources. This response code is sent when the request is a conditional GET or HEAD request with an If-None-Match or an If-Modified-Since header and the condition evaluates to false. It is an implicit redirection to a cached resource that would have resulted in a 200 OK response if the condition evaluated to true.

The response must not contain a body and must include the headers that would have been sent in an equivalent 200 OK response: Cache-Control, Content-Location, Date, ETag, Expires, and Vary.

Note: Many developer tools' network panels of browsers create extraneous requests leading to 304 responses, so that access to the local cache is visible to developers.

Documentation: copyright MDN Contributors under CC-BY-SA 2.5

See

https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/304

Defined in

http.ts:437

Ok

• Ok = 200

200 OK

The HTTP 200 OK success status response code indicates that the request has succeeded. A 200 response is cacheable by default.

The meaning of a success depends on the HTTP request method:

The successful result of a PUT or a DELETE is often not a 200 OK but a 204 No Content (or a 201 Created when the resource is uploaded for the first time).

Documentation: copyright MDN Contributors under CC-BY-SA 2.5

See

https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/200

Defined in

http.ts:155

PartialContent

• PartialContent = 206

206 Partial Content

The HTTP 206 Partial Content success status response code indicates that the request has succeeded and the body contains the requested ranges of data, as described in the Range header of the request.

If there is only one range, the Content-Type of the whole response is set to the type of the document, and a Content-Range is provided.

If several ranges are sent back, the Content-Type is set to multipart/byteranges and each fragment covers one range, with Content-Range and Content-Type describing it.

Documentation: copyright MDN Contributors under CC-BY-SA 2.5

See

https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/206

Defined in

http.ts:279

PaymentRequired

• PaymentRequired = 402

402 Payment Required

Experimental: This is an experimental technology Check the Browser compatibility table carefully before using this in production.

The HTTP 402 Payment Required is a nonstandard response status code that is reserved for future use. This status code was created to enable digital cash or (micro) payment systems and would indicate that the requested content is not available until the client makes a payment.

Sometimes, this status code indicates that the request cannot be processed until the client makes a payment. However, no standard use convention exists and different entities use it in different contexts.

Documentation: copyright MDN Contributors under CC-BY-SA 2.5

See

https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/402

Defined in

http.ts:584

PermanentRedirect

• PermanentRedirect = 308

308 Permanent Redirect

The HyperText Transfer Protocol (HTTP) 308 Permanent Redirect redirect status response code indicates that the resource requested has been definitively moved to the URL given by the Location headers. A browser redirects to this page and search engines update their links to the resource (in 'SEO-speak', it is said that the 'link-juice' is sent to the new URL).

The request method and the body will not be altered, whereas 301 may incorrectly sometimes be changed to a GET method.

Note: Some Web applications may use the 308 Permanent Redirect in a non-standard way and for other purposes. For example, Google Drive uses a 308 Resume Incomplete response to indicate to the client when an incomplete upload stalled. (See Perform a resumable download on Google Drive documentation.)

Documentation: copyright MDN Contributors under CC-BY-SA 2.5

See

https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/308

Defined in

http.ts:517

PreconditionFailed

• PreconditionFailed = 412

412 Precondition Failed

The HyperText Transfer Protocol (HTTP) 412 Precondition Failed client error response code indicates that access to the target resource has been denied. This happens with conditional requests on methods other than GET or HEAD when the condition defined by the If-Unmodified-Since or If-None-Match headers is not fulfilled. In that case, the request, usually an upload or a modification of a resource, cannot be made and this error response is sent back.

Documentation: copyright MDN Contributors under CC-BY-SA 2.5

See

https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/412

Defined in

http.ts:789

PreconditionRequired

• PreconditionRequired = 428

428 Precondition Required

The HTTP 428 Precondition Required response status code indicates that the server requires the request to be conditional.

Typically, this means that a required precondition header, such as If-Match, is missing.

When a precondition header is not matching the server side state, the response should be 412 Precondition Failed.

Documentation: copyright MDN Contributors under CC-BY-SA 2.5

See

https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/428

Defined in

http.ts:986

Processing

• Processing = 102

Processing

WebDAV

A WebDAV request may contain many sub-requests involving file operations, requiring 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 the request was lost.

Defined in

http.ts:93

ProxyAuthenticationRequired

• ProxyAuthenticationRequired = 407

407 Proxy Authentication Required

The HTTP 407 Proxy Authentication Required client error status response code indicates that the request has not been applied because it lacks valid authentication credentials for a proxy server that is between the browser and the server that can access the requested resource.

This status is sent with a Proxy-Authenticate header that contains information on how to authorize correctly.

Documentation: copyright MDN Contributors under CC-BY-SA 2.5

See

https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/407

Defined in

http.ts:686

RangeNotSatisfiable

• RangeNotSatisfiable = 416

416 Range Not Satisfiable

The HyperText Transfer Protocol (HTTP) 416 Range Not Satisfiable error response code indicates that a server cannot serve the requested ranges. The most likely reason is that the document doesn't contain such ranges, or that the Range header value, though syntactically correct, doesn't make sense.

The 416 response message contains a Content-Range indicating an unsatisfied range (that is a '*') followed by a '/' and the current length of the resource. E.g. Content-Range: bytes *​/12777

Faced with this error, browsers usually either abort the operation (for example, a download will be considered as non-resumable) or ask for the whole document again.

Documentation: copyright MDN Contributors under CC-BY-SA 2.5

See

https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/416

Defined in

http.ts:868

RequestHeaderFieldsTooLarge

• RequestHeaderFieldsTooLarge = 431

431 Request Header Fields Too Large

The HTTP 431 Request Header Fields Too Large response status code indicates that the server refuses to process the request because the request's HTTP headers are too long. The request may be resubmitted after reducing the size of the request headers.

431 can be used when the total size of request headers is too large, or when a single header field is too large. To help those running into this error, indicate which of the two is the problem in the response body — ideally, also include which headers are too large. This lets users attempt to fix the problem, such as by clearing their cookies.

Servers will often produce this status if:

Documentation: copyright MDN Contributors under CC-BY-SA 2.5

See

https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/431

Defined in

http.ts:1026

RequestTimeout

• RequestTimeout = 408

408 Request Timeout

The HyperText Transfer Protocol (HTTP) 408 Request Timeout response status code means that the server would like to shut down this unused connection. It is sent on an idle connection by some servers, even without any previous request by the client.

A server should send the "close" Connection header field in the response, since 408 implies that the server has decided to close the connection rather than continue waiting.

This response is used much more since some browsers, like Chrome, Firefox 27+, and IE9, use HTTP pre-connection mechanisms to speed up surfing.

Note: some servers merely shut down the connection without sending this message.

Documentation: copyright MDN Contributors under CC-BY-SA 2.5

See

https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/408

Defined in

http.ts:710

ResetContent

• ResetContent = 205

205 Reset Content

The HTTP 205 Reset Content response status tells the client to reset the document view, so for example to clear the content of a form, reset a canvas state, or to refresh the UI.

Documentation: copyright MDN Contributors under CC-BY-SA 2.5

See

https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/205

Defined in

http.ts:254

SeeOther

• SeeOther = 303

303 See Other

The HyperText Transfer Protocol (HTTP) 303 See Other redirect status response code indicates that the redirects don't link to the requested resource itself, but to another page (such as a confirmation page, a representation of a real-world object — see HTTP range-14 — or an upload-progress page). This response code is often sent back as a result of PUT or POST. The method used to display this redirected page is always GET.

Documentation: copyright MDN Contributors under CC-BY-SA 2.5

See

https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/303

Defined in

http.ts:403

ServiceUnavailable

• ServiceUnavailable = 503

503 Service Unavailable

The HyperText Transfer Protocol (HTTP) 503 Service Unavailable server error response code indicates that the server is not ready to handle the request.

Common causes are a server that is down for maintenance or that is overloaded. This response should be used for temporary conditions and the Retry-After HTTP header should, if possible, contain the estimated time for the recovery of the service.

Note: together with this response, a user-friendly page explaining the problem should be sent.

Caching-related headers that are sent along with this response should be taken care of, as a 503 status is often a temporary condition and responses shouldn't usually be cached.

Documentation: copyright MDN Contributors under CC-BY-SA 2.5

See

https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/503

Defined in

http.ts:1155

SwitchProxy

• SwitchProxy = 306

Switch Proxy

Originally meant "Subsequent requests should use the specified proxy".

Deprecated

No longer used

Since

HTTP/1.1

Defined in

http.ts:461

SwitchingProtocols

• SwitchingProtocols = 101

101 Switching Protocols

The HTTP 101 Switching Protocols response code indicates a protocol to which the server switches. The protocol is specified in the Upgrade request header received from a client.

The server includes in this response an Upgrade response header to indicate the protocol it switched to. The process is described in the following article: Protocol upgrade mechanism.

Documentation: copyright MDN Contributors under CC-BY-SA 2.5

See

https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/101

Defined in

http.ts:78

TemporaryRedirect

• TemporaryRedirect = 307

307 Temporary Redirect

HTTP 307 Temporary Redirect redirect status response code indicates that the resource requested has been temporarily moved to the URL given by the Location headers.

The method and the body of the original request are reused to perform the redirected request. In the cases where you want the method used to be changed to GET, use 303 See Other instead. This is useful when you want to give an answer to a PUT method that is not the uploaded resources, but a confirmation message (like "You successfully uploaded XYZ").

The only difference between 307 and 302 is that 307 guarantees that the method and the body will not be changed when the redirected request is made. With 302, some old clients were incorrectly changing the method to GET: the behavior with non-GET methods and 302 is then unpredictable on the Web, whereas the behavior with 307 is predictable. For GET requests, their behavior is identical.

Documentation: copyright MDN Contributors under CC-BY-SA 2.5

See

https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/307

Defined in

http.ts:490

TooManyRequests

• TooManyRequests = 429

429 Too Many Requests

The HTTP 429 Too Many Requests response status code indicates the user has sent too many requests in a given amount of time ("rate limiting").

A Retry-After header might be included to this response indicating how long to wait before making a new request.

Documentation: copyright MDN Contributors under CC-BY-SA 2.5

See

https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/429

Defined in

http.ts:1003

URITooLong

• URITooLong = 414

414 URI Too Long

The HTTP 414 URI Too Long response status code indicates that the URI requested by the client is longer than the server is willing to interpret.

There are a few rare conditions when this might occur:

Documentation: copyright MDN Contributors under CC-BY-SA 2.5

See

https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/414

Defined in

http.ts:823

Unauthorized

• Unauthorized = 401

401 Unauthorized

The HyperText Transfer Protocol (HTTP) 401 Unauthorized response status code indicates that the client request has not been completed because it lacks valid authentication credentials for the requested resource.

This status code is sent with an HTTP WWW-Authenticate response header that contains information on how the client can request for the resource again after prompting the user for authentication credentials.

This status code is similar to the 403 Forbidden status code, except that in situations resulting in this status code, user authentication can allow access to the resource.

Documentation: copyright MDN Contributors under CC-BY-SA 2.5

See

https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/401

Defined in

http.ts:559

UnavailableForLegalReasons

• UnavailableForLegalReasons = 451

451 Unavailable For Legal Reasons

The HyperText Transfer Protocol (HTTP) 451 Unavailable For Legal Reasons client error response code indicates that the user requested a resource that is not available due to legal reasons, such as a web page for which a legal action has been issued.

Documentation: copyright MDN Contributors under CC-BY-SA 2.5

See

https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/451

Defined in

http.ts:1041

UnprocessableContent

• UnprocessableContent = 422

422 Unprocessable Content

The HyperText Transfer Protocol (HTTP) 422 Unprocessable Content response status code indicates that the server understands the content type of the request entity, and the syntax of the request entity is correct, but it was unable to process the contained instructions.

Warning: The client should not repeat this request without modification.

Documentation: copyright MDN Contributors under CC-BY-SA 2.5

See

https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/422

Defined in

http.ts:930

UnsupportedMediaType

• UnsupportedMediaType = 415

415 Unsupported Media Type

The HTTP 415 Unsupported Media Type client error response code indicates that the server refuses to accept the request because the payload format is in an unsupported format.

The format problem might be due to the request's indicated Content-Type or Content-Encoding, or as a result of inspecting the data directly.

Documentation: copyright MDN Contributors under CC-BY-SA 2.5

See

https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/415

Defined in

http.ts:843

UpgradeRequired

• UpgradeRequired = 426

426 Upgrade Required

The HTTP 426 Upgrade Required client error response code indicates that the server refuses to perform the request using the current protocol but might be willing to do so after the client upgrades to a different protocol.

The server sends an Upgrade header with this response to indicate the required protocol(s).

Documentation: copyright MDN Contributors under CC-BY-SA 2.5

See

https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/426

Defined in

http.ts:966

UseProxy

• UseProxy = 305

Use Proxy

The requested resource is available only through a proxy, the address for which is provided in the response.

Many HTTP clients (such as Mozilla and Internet Explorer) do not correctly handle responses with this status code, primarily for security reasons.

Deprecated

Due to security concerns regarding in-band configuration of a proxy

Since

HTTP/1.1

Defined in

http.ts:451

VariantAlsoNegotiates

• VariantAlsoNegotiates = 506

506 Variant Also Negotiates

The HyperText Transfer Protocol (HTTP) 506 Variant Also Negotiates response status code may be given in the context of Transparent Content Negotiation (see RFC 2295). This protocol enables a client to retrieve the best variant of a given resource, where the server supports multiple variants.

The Variant Also Negotiates status code indicates an internal server configuration error in which the chosen variant is itself configured to engage in content negotiation, so is not a proper negotiation endpoint.

Documentation: copyright MDN Contributors under CC-BY-SA 2.5

See

https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/506

Defined in

http.ts:1209