HTTP Status Codes Reference
Comprehensive searchable reference for all HTTP status codes with detailed explanations and common use cases.
Showing 61 of 61 status codes
Most Common Status Codes
OK
The request succeeded. The meaning of success depends on the HTTP method used.
Created
The request succeeded and a new resource was created as a result.
No Content
The request succeeded, but there is no content to send in the response.
Moved Permanently
The URL of the requested resource has been changed permanently. The new URL is in the response.
Found
The URI of the requested resource has been changed temporarily. Further changes may be made in the future.
Not Modified
Indicates that the resource has not been modified since the version specified by the request headers.
Bad Request
The server cannot process the request due to client error (e.g., malformed request syntax).
Unauthorized
The client must authenticate itself to get the requested response.
Forbidden
The client does not have access rights to the content; authentication will not help.
Not Found
The server cannot find the requested resource. This is the most common error code.
All HTTP Status Codes
Continue
InformationalThe server has received the request headers and the client should proceed to send the request body.
Common Use Cases:
- Large file uploads where the client wants to check if the server will accept the request before sending the body
- Expectation validation in HTTP/1.1
Switching Protocols
InformationalThe server is switching protocols as requested by the client (e.g., from HTTP to WebSocket).
Common Use Cases:
- WebSocket handshake upgrade
- Protocol upgrades in HTTP/2
Processing
InformationalThe server has received and is processing the request, but no response is available yet.
Common Use Cases:
- WebDAV operations that take a long time
- Complex server-side operations
Early Hints
InformationalUsed to return some response headers before the final HTTP message.
Common Use Cases:
- Preloading resources while the server prepares the response
- Performance optimization for critical resources
OK
SuccessThe request succeeded. The meaning of success depends on the HTTP method used.
Common Use Cases:
- GET: Successfully retrieved resource
- POST: Successfully created or processed resource
- PUT: Successfully updated resource
- Most common successful response
Created
SuccessThe request succeeded and a new resource was created as a result.
Common Use Cases:
- POST requests that create new resources
- User registration endpoints
- Creating new database records via API
Accepted
SuccessThe request has been accepted for processing, but processing has not been completed.
Common Use Cases:
- Asynchronous operations
- Batch processing jobs
- Queue-based systems where processing happens later
Non-Authoritative Information
SuccessThe request was successful but the enclosed payload has been modified by a transforming proxy.
Common Use Cases:
- Proxy servers modifying responses
- CDN transformations
No Content
SuccessThe request succeeded, but there is no content to send in the response.
Common Use Cases:
- DELETE operations
- PUT updates that don't return updated data
- Successful operations with no response body needed
Reset Content
SuccessThe server successfully processed the request and is instructing the client to reset the document view.
Common Use Cases:
- Form submissions where the form should be cleared
- Data entry applications
Partial Content
SuccessThe server is delivering only part of the resource due to a range header sent by the client.
Common Use Cases:
- Video/audio streaming
- Resumable downloads
- Large file downloads with range requests
Multi-Status
SuccessThe response contains multiple status codes for different parts of the operation.
Common Use Cases:
- WebDAV operations on multiple resources
- Batch operations with mixed results
Already Reported
SuccessThe members of a DAV binding have already been enumerated in a previous reply.
Common Use Cases:
- WebDAV to avoid repeatedly enumerating bindings
IM Used
SuccessThe server has fulfilled a request for the resource with instance manipulations applied.
Common Use Cases:
- Delta encoding in HTTP
- Bandwidth optimization
Multiple Choices
RedirectionThe request has more than one possible response. The user or user agent should choose one.
Common Use Cases:
- Content negotiation
- Multiple format options (HTML, JSON, XML)
Moved Permanently
RedirectionThe URL of the requested resource has been changed permanently. The new URL is in the response.
Common Use Cases:
- Website migrations
- URL structure changes
- SEO-friendly permanent redirects
Found
RedirectionThe URI of the requested resource has been changed temporarily. Further changes may be made in the future.
Common Use Cases:
- Temporary redirects
- A/B testing
- Maintenance redirects
See Other
RedirectionThe server sent this response to direct the client to get the requested resource at another URI with a GET request.
Common Use Cases:
- POST/PUT/DELETE followed by redirect to result page
- Form submission redirects
Not Modified
RedirectionIndicates that the resource has not been modified since the version specified by the request headers.
Common Use Cases:
- Browser caching with If-Modified-Since header
- ETags for cache validation
- API response caching
Temporary Redirect
RedirectionThe server sends this response to direct the client to get the requested resource at another URI with the same method.
Common Use Cases:
- Temporary redirects preserving HTTP method
- Load balancing
- Maintenance mode redirects
Permanent Redirect
RedirectionThe resource is now permanently located at another URI, and the HTTP method should be preserved.
Common Use Cases:
- Permanent redirects preserving POST/PUT methods
- API versioning
Bad Request
Client ErrorThe server cannot process the request due to client error (e.g., malformed request syntax).
Common Use Cases:
- Invalid JSON in request body
- Missing required parameters
- Validation errors
- Malformed request syntax
Unauthorized
Client ErrorThe client must authenticate itself to get the requested response.
Common Use Cases:
- Missing authentication credentials
- Invalid API token
- Expired session
- Login required
Payment Required
Client ErrorReserved for future use. Originally intended for digital payment systems.
Common Use Cases:
- Payment required for content access
- Subscription or quota limits exceeded
Forbidden
Client ErrorThe client does not have access rights to the content; authentication will not help.
Common Use Cases:
- Insufficient permissions
- IP address blocked
- Resource access denied
- Admin-only endpoints
Not Found
Client ErrorThe server cannot find the requested resource. This is the most common error code.
Common Use Cases:
- Page or resource doesn't exist
- Broken links
- Typos in URL
- Deleted resources
Method Not Allowed
Client ErrorThe request method is known by the server but is not supported by the target resource.
Common Use Cases:
- Using POST on a read-only endpoint
- DELETE not allowed on resource
- API method restrictions
Not Acceptable
Client ErrorThe server cannot produce a response matching the Accept headers sent by the client.
Common Use Cases:
- Content negotiation failure
- Unsupported response format requested
Proxy Authentication Required
Client ErrorThe client must first authenticate itself with the proxy.
Common Use Cases:
- Corporate proxy authentication
- Network proxy access control
Request Timeout
Client ErrorThe server timed out waiting for the request from the client.
Common Use Cases:
- Slow client connections
- Network issues
- Keep-alive timeout
Conflict
Client ErrorThe request conflicts with the current state of the server.
Common Use Cases:
- Version conflicts
- Duplicate resource creation
- Concurrent modification conflicts
- Business logic conflicts
Gone
Client ErrorThe requested resource is no longer available and will not be available again.
Common Use Cases:
- Permanently deleted resources
- Deprecated API endpoints
- Expired content
Length Required
Client ErrorThe server requires the Content-Length header field in the request.
Common Use Cases:
- Upload endpoints requiring content length
- API requiring payload size declaration
Precondition Failed
Client ErrorThe server does not meet one of the preconditions specified in the request headers.
Common Use Cases:
- If-Match header validation failure
- Conditional requests
- Optimistic locking
Payload Too Large
Client ErrorThe request entity is larger than limits defined by the server.
Common Use Cases:
- File upload size exceeded
- Request body too large
- POST data exceeds limits
URI Too Long
Client ErrorThe URI requested by the client is longer than the server is willing to interpret.
Common Use Cases:
- Extremely long query strings
- Too many parameters in URL
- Long GET requests that should be POST
Unsupported Media Type
Client ErrorThe media format of the requested data is not supported by the server.
Common Use Cases:
- Wrong Content-Type header
- Unsupported file format
- JSON expected but XML sent
Range Not Satisfiable
Client ErrorThe range specified by the Range header field in the request cannot be fulfilled.
Common Use Cases:
- Invalid byte range in streaming
- Seeking beyond file size
Expectation Failed
Client ErrorThe expectation indicated by the Expect request header field cannot be met.
Common Use Cases:
- Expect: 100-continue not supported
I'm a Teapot
Client ErrorThe server refuses to brew coffee because it is, permanently, a teapot. (April Fools' joke from RFC 2324)
Common Use Cases:
- Easter egg responses
- Humorous error pages
- Testing and demonstration
Misdirected Request
Client ErrorThe request was directed at a server that is not able to produce a response.
Common Use Cases:
- HTTP/2 connection issues
- Server name indication problems
Unprocessable Entity
Client ErrorThe request was well-formed but contains semantic errors.
Common Use Cases:
- Validation errors
- Business rule violations
- Invalid data format (correct syntax, wrong values)
Locked
Client ErrorThe resource that is being accessed is locked.
Common Use Cases:
- WebDAV locked resources
- File editing conflicts
Failed Dependency
Client ErrorThe request failed because it depended on another request that failed.
Common Use Cases:
- WebDAV operations with dependencies
- Multi-step operations
Too Early
Client ErrorThe server is unwilling to risk processing a request that might be replayed.
Common Use Cases:
- TLS early data protection
- Replay attack prevention
Upgrade Required
Client ErrorThe server requires the client to upgrade to a different protocol.
Common Use Cases:
- Forcing HTTPS upgrade
- Protocol version upgrades
Precondition Required
Client ErrorThe server requires the request to be conditional.
Common Use Cases:
- Preventing lost updates
- Requiring If-Match headers
Too Many Requests
Client ErrorThe user has sent too many requests in a given amount of time (rate limiting).
Common Use Cases:
- API rate limiting
- DDoS protection
- Throttling excessive requests
- Preventing abuse
Request Header Fields Too Large
Client ErrorThe server is unwilling to process the request because its header fields are too large.
Common Use Cases:
- Too many cookies
- Oversized headers
Unavailable For Legal Reasons
Client ErrorThe user requests an illegal resource, such as content censored by a government.
Common Use Cases:
- DMCA takedowns
- Government censorship
- Legal compliance blocks
Internal Server Error
Server ErrorThe server encountered an unexpected condition that prevented it from fulfilling the request.
Common Use Cases:
- Unhandled exceptions
- Server-side bugs
- Database connection failures
- Generic server errors
Not Implemented
Server ErrorThe request method is not supported by the server and cannot be handled.
Common Use Cases:
- Unsupported HTTP methods
- Features not yet implemented
- Legacy API endpoints
Bad Gateway
Server ErrorThe server, while acting as a gateway or proxy, received an invalid response from the upstream server.
Common Use Cases:
- Upstream server errors
- Proxy communication issues
- Load balancer problems
- Microservice failures
Service Unavailable
Server ErrorThe server is not ready to handle the request, often due to maintenance or overload.
Common Use Cases:
- Server maintenance
- Server overload
- Temporary downtime
- Rate limiting (alternative to 429)
Gateway Timeout
Server ErrorThe server acting as a gateway did not receive a timely response from the upstream server.
Common Use Cases:
- Upstream server timeout
- Slow database queries
- Long-running operations
- Network connectivity issues
HTTP Version Not Supported
Server ErrorThe HTTP version used in the request is not supported by the server.
Common Use Cases:
- HTTP version mismatches
- Legacy protocol versions
Variant Also Negotiates
Server ErrorThe server has an internal configuration error with content negotiation.
Common Use Cases:
- Content negotiation circular reference
- Server misconfiguration
Insufficient Storage
Server ErrorThe server is unable to store the representation needed to complete the request.
Common Use Cases:
- WebDAV storage quota exceeded
- Disk space exhausted
- Upload storage limits
Loop Detected
Server ErrorThe server detected an infinite loop while processing the request.
Common Use Cases:
- WebDAV infinite loops
- Circular redirect chains
Not Extended
Server ErrorFurther extensions to the request are required for the server to fulfill it.
Common Use Cases:
- HTTP extension framework
- Additional protocol requirements
Network Authentication Required
Server ErrorThe client needs to authenticate to gain network access (e.g., captive portal).
Common Use Cases:
- WiFi hotspot login pages
- Captive portals
- Network access control
Quick Reference Table
| Code | Name | Category | Description |
|---|---|---|---|
| 200 | OK | Success | The request succeeded. The meaning of success depends on the HTTP method used. |
| 201 | Created | Success | The request succeeded and a new resource was created as a result. |
| 204 | No Content | Success | The request succeeded, but there is no content to send in the response. |
| 301 | Moved Permanently | Redirection | The URL of the requested resource has been changed permanently. The new URL is in the response. |
| 302 | Found | Redirection | The URI of the requested resource has been changed temporarily. Further changes may be made in the future. |
| 304 | Not Modified | Redirection | Indicates that the resource has not been modified since the version specified by the request headers. |
| 400 | Bad Request | Client Error | The server cannot process the request due to client error (e.g., malformed request syntax). |
| 401 | Unauthorized | Client Error | The client must authenticate itself to get the requested response. |
| 403 | Forbidden | Client Error | The client does not have access rights to the content; authentication will not help. |
| 404 | Not Found | Client Error | The server cannot find the requested resource. This is the most common error code. |
| 429 | Too Many Requests | Client Error | The user has sent too many requests in a given amount of time (rate limiting). |
| 500 | Internal Server Error | Server Error | The server encountered an unexpected condition that prevented it from fulfilling the request. |
| 502 | Bad Gateway | Server Error | The server, while acting as a gateway or proxy, received an invalid response from the upstream server. |
| 503 | Service Unavailable | Server Error | The server is not ready to handle the request, often due to maintenance or overload. |
Searchable Database
Quickly find status codes by number, name, or description with instant search.
Category Filtering
Filter by category: Informational, Success, Redirection, Client Error, or Server Error.
Detailed Explanations
Each code includes description and real-world use cases for better understanding.
Frequently Asked Questions
What are HTTP status codes?
HTTP status codes are three-digit numbers returned by web servers to indicate the result of a client's request. They are grouped into five categories: 1xx (Informational), 2xx (Success), 3xx (Redirection), 4xx (Client Error), and 5xx (Server Error). Each code provides specific information about how the request was processed.
What's the difference between 401 and 403?
401 Unauthorized means authentication is required but was not provided or failed - the request needs valid credentials. 403 Forbidden means the server understood the request but refuses to authorize it - even with authentication, the user lacks the necessary permissions. In other words, 401 means "you need to log in" while 403 means "you're logged in but you don't have access."
When should I use 301 vs 302?
Use 301 Moved Permanently for permanent URL changes. Search engines will update their indexes and transfer SEO value to the new URL. Use 302 Found (or 307 Temporary Redirect) for temporary redirects where the original URL will be used again in the future. 302 tells search engines to keep the original URL in their index.
What does 418 I'm a Teapot mean?
418 I'm a Teapot is an April Fools' joke from RFC 2324, which defined the Hyper Text Coffee Pot Control Protocol (HTCPCP). While humorous, some servers use it as an easter egg or to indicate they refuse to brew coffee because they're a teapot. It's occasionally used by developers for humorous error pages or to reject certain types of requests.
What's the difference between 502 and 504?
Both involve proxy or gateway scenarios. 502 Bad Gateway means the upstream server sent an invalid or malformed response. 504 Gateway Timeout means the upstream server didn't respond within the allowed time period. Think of 502 as "the upstream server responded, but with garbage" and 504 as "the upstream server didn't respond at all."
When should I return 204 No Content?
Use 204 No Content for successful requests that don't need to return any data in the response body. This is commonly used for DELETE operations (resource deleted successfully, nothing to return), PUT updates where you don't need to send the updated resource back, or successful actions that require no response data. It tells the client "success, but I have nothing to send you."