The server has received the request headers and the client may proceed to send the request body. This mechanism is mainly used for large uploads to avoid bandwidth waste if the server is going to reject the request.
Possible causes
  • Client uses `Expect: 100-continue` header to ask for approval before sending body
  • Request body may be large (e.g., file upload), requiring header validation first
Recommended solutions
  • No special handling needed; this mechanism optimizes upload efficiency
  • Ensure client correctly sets the `Expect` header and server responds with 100 or a final status
  • If server doesn't support it, remove the header and send the full request
The server agrees to switch protocols as requested via the Upgrade header (e.g., to WebSocket, HTTP/2, or HTTP/3). The connection now follows a different protocol.
Possible causes
  • Client sends `Connection: upgrade` with the desired protocol (e.g., WebSocket)
  • Server supports the protocol and accepts the switch
Recommended solutions
  • Ensure client and server support the same protocol and version
  • Validate handshake headers (e.g., Sec-WebSocket-Key, Sec-WebSocket-Protocol)
  • If switch fails, return appropriate error code like 426 or 400
A WebDAV extension status code indicating that the server has received and is processing the request (such as generating a long report), but no response is available yet. Used to avoid client timeouts.
Possible causes
  • Long-running tasks such as complex queries, file writes, or sync operations
  • WebDAV server sends 102 per RFC to keep connection alive
Recommended solutions
  • Client should keep the connection open and wait for final response
  • Server must eventually send a final status (e.g., 200, 207)
  • Use case: batch jobs, large file handling, transactional requests
The server sends early hints (like Link: preload headers) before the final response to allow the browser to start loading resources earlier. A normal response (200/3xx/etc.) will follow.
Possible causes
  • Server intends to preload CSS/JS/images, etc.
  • Often used with HTTP/2 push or browser preload mechanisms
Recommended solutions
  • Frontend can preload resources based on response headers
  • No extra handling needed; browsers process hints automatically
  • Server should still send the final response
Defined in IETF draft (non-standard). Indicates server support for resumable uploads, such as via HTTP-based protocols like tus.io or Resumable.js.
Possible causes
  • Client initiates a HEAD or OPTIONS request with resumable upload support
  • Server uses 104 to advertise its resumable upload capability
  • Used in large file uploads or unstable network conditions
Recommended solutions
  • Client can use 104 to determine whether to enable resumable upload
  • On failure, reuse uploaded parts and send only remaining data
  • Use content hashes or file IDs to verify upload segments and resume accurately
The request has been successfully processed and returns the requested resource or operation result. HTTP methods:
- GET: Returns the requested resource
- POST/PUT/DELETE: Returns the processing result
- HEAD: Returns response headers without body content
Possible causes
  • Client request syntax, parameters and headers are complete and compliant
  • Server business logic executed normally without errors
Recommended solutions
  • No further action needed, indicates successful completion
  • Frontend can update UI or state based on API response
The request has been successfully processed and a new resource was created on the server. Response typically includes Location header pointing to the new resource address, and may include the resource content.
Possible causes
  • Client initiated resource creation request (e.g. POST /users)
  • Server successfully created resource through database/storage
Recommended solutions
  • Frontend can obtain new resource address from Location header and redirect
  • Alternatively refresh list and show creation success message based on response
The request has been accepted for processing but is not yet completed. Used for asynchronous operations or delayed processing scenarios. Response may include task ID for follow-up queries.
Possible causes
  • Request involves asynchronous operations like batch jobs, exports, uploads
  • Server queued the task rather than processing immediately
Recommended solutions
  • Frontend should poll task status periodically or subscribe to completion notifications
  • Display 'processing' status and update UI when complete
The request succeeded but the response may come from a third-party proxy and differs from the original resource. Typically used when proxy caches modify content.
Possible causes
  • Client request went through proxy/CDN returning cached content
  • Proxy modified response content before returning to client
Recommended solutions
  • Verify content accuracy, bypass cache to get from origin server if needed
  • Implement version control for cached content to ensure consistency
The server successfully processed the request but returns no content. Suitable for operations that don't require refreshing page resources, like form submissions or deletions.
Possible causes
  • Request only performs business operations without returning data
  • Used to save bandwidth and optimize request efficiency
Recommended solutions
  • Frontend can refresh page, clear form or reset state based on logic
  • Avoid returning empty response bodies, maintain controlled state updates
After request completion, the server asks the client to reset the view or layout. Typically used to clear forms or reset edit pages.
Possible causes
  • After form submission, input fields need clearing or page content reset
  • Used to reset UI structure before 'repeat submissions'
Recommended solutions
  • Frontend should clear forms and reset component states
  • Suitable for SPA scenarios requiring edit state resets
The server responded to a partial content request, commonly used for resumable downloads or media streaming. Client uses Range requests to implement segmented processing.
Possible causes
  • Client sent Range request (e.g. video resumable download)
  • Server supports Range and responded with partial content
Recommended solutions
  • Frontend can combine multiple segments into complete resource
  • Suitable for large file downloads, video playback with resume capability
WebDAV extension status code representing multiple sub-request statuses. Response body contains XML with execution results for each sub-request.
Possible causes
  • Batch operations like copying/deleting multiple resources
  • Server supports WebDAV and returns multi-status XML
Recommended solutions
  • Parse XML to handle successful/failed sub-items
  • Suitable for batch transaction scenarios
WebDAV avoids redundantly reporting already listed member statuses in responses to optimize information.
Possible causes
  • Client requested collection resource properties, server avoids duplicate listings
  • Uses internal cache or deduplication to optimize responses
Recommended solutions
  • Frontend can ignore reported items and focus on new members
  • Suitable for batch collection status processing
RFC 3229 defined status code indicating the response represents the result of applying instance manipulations (like delta encoding) to the original resource.
Possible causes
  • Client supports Delta Encoding and sent related requests
  • Server generated response based on resource differences
Recommended solutions
  • Frontend parses delta operations: identify modifications, deletions, additions
  • Suitable for cache updates and bandwidth optimization
The server returns multiple available resource options.
The client should choose one of the URIs or handle redirection automatically in the response body.
Possible causes
  • Requested resource has multiple representations (e.g. different languages/formats)
  • Server wants client to explicitly select the resulting resource
Recommended solutions
  • Client automatically selects most suitable resource or prompts user with GUI
  • Set explicit Location header for automatic redirect if no user interaction needed
Resource has permanently moved to a new URI.
Clients should update references, this response can be cached and future requests should use the new address.
Possible causes
  • Website migrated to new domain or directory structure changed
  • Old links used for SEO redirect purposes
Recommended solutions
  • Update bookmarks and old URL references in frontend applications
  • Ensure server returns Location header pointing to permanent address
  • Use 301 redirect to consolidate SEO link equity
Resource is temporarily available from a different URI.
Clients should continue using the original URL, with server typically providing Location header for temporary redirect.
Possible causes
  • Resource temporarily relocated (e.g. during maintenance)
  • Commonly used for post-login redirects or A/B testing page switching
Recommended solutions
  • Client should immediately redirect but continue using original URL for future requests
  • Ensure POST/PUT requests aren't incorrectly converted to GET
Response directs client to use GET method at another URI to fetch resource, typically used as POST redirect.
Prevents duplicate submissions.
Possible causes
  • After form submission to redirect user to results page
  • Preventing POST resubmission on refresh
Recommended solutions
  • Client should use GET to request URI specified in Location header
  • Backend should specify resource location in Location header
Resource has not been modified since last request.
Client can continue using cached version without redownloading.
Possible causes
  • Client sent conditional request with If-Modified-Since or If-None-Match
  • Server determined content unchanged and returns 304 to save bandwidth
Recommended solutions
  • Client should use locally cached resource
  • Frontend can update cache if request fails or new content available
Request must be accessed through specified proxy.
This status is rare and most modern browsers ignore it.
Possible causes
  • Server requires client to use specific proxy to access target resource
  • Common in closed networks or enterprise environments
Recommended solutions
  • Configure required proxy or update access path through server
  • Modern web applications should avoid using this status
This status code is deprecated and no longer used.
Originally indicated client should switch proxy servers, now retained for legacy purposes.
Possible causes
  • Legacy status code with no current usage scenarios
Recommended solutions
  • Should not be used or relied upon
  • Can be safely ignored if encountered
Resource temporarily moved, client should resend request with same method (e.g. unchanged POST) to URI in Location header.
Unlike 302, guarantees method preservation.
Possible causes
  • Resource temporarily relocated without changing usage patterns
  • Used for upgraded short-term redirect logic
Recommended solutions
  • Client should resend request with same HTTP method to new URI
  • Ensure Location header points to correct destination
Permanent redirect where client should preserve request method and redirect to new URI.
Unlike 301, suitable for REST API migration scenarios.
Possible causes
  • API endpoint permanently changed but methods need preservation
  • Server wants client to remember both request method and new address
Recommended solutions
  • Client should resend request with same HTTP method to new URL
  • Ideal for permanent migrations preserving POST/PUT semantics
The server cannot understand the request.
Common causes include malformed JSON, missing required fields, Content-Type mismatch, or invalid URL format.
Possible causes
  • Failed to parse JSON/XML request body
  • Missing required parameters or field type errors
  • Content-Type doesn't match actual content
  • Unencoded or malformed query parameters
Recommended solutions
  • Inspect request structure using developer tools
  • Complete missing fields and set correct Content-Type
  • Encode or fix URL parameters
Authentication failed.
Client didn't provide valid credentials (token/cookie) or credentials are expired/invalid.
Possible causes
  • Missing Authorization header or token
  • Token expired or invalid signature
  • Session/Cookie invalidated
Recommended solutions
  • Prompt user to login or refresh credentials
  • Include valid credentials in request header
  • Server should guide auth flow via WWW-Authenticate
Reserved for experimental use.
Originally intended for digital payment scenarios when accessing paid resources. Rarely used in practice.
Possible causes
  • Attempting to access paid content without payment
  • Subscription expired or account balance insufficient
  • Exceeded free tier quota for third-party API
  • Some platforms use as 'soft ban' requiring payment upgrade
Recommended solutions
  • Guide user through payment process
  • Check account balance and payment methods
  • API consumers should handle payment requirements
  • Include payment links in response when applicable
Server understood the request but refuses to execute it.
Authenticated but insufficient permissions or security policy restrictions.
Possible causes
  • User role lacks required permissions
  • Resource protected by ACL/IP restrictions
  • CORS policy not configured
Recommended solutions
  • Verify and grant user access permissions
  • Adjust security policies or CORS settings
  • Use account with proper access privileges
Requested resource does not exist.
May be caused by API changes, URL typos, deleted resources, or misconfigured routing.
Possible causes
  • URL path contains typos or structural changes
  • Resource was deleted without proper redirects
  • Reverse proxy or frontend routing misconfiguration
Recommended solutions
  • Double-check URL spelling
  • Implement proper redirects (301/302) for moved resources
  • Verify routing/proxy configurations
The request method is not allowed.
Server recognizes the path but doesn't support the current HTTP method (e.g. PUT request to GET-only resource).
Possible causes
  • Using HTTP method not supported by the API
  • Backend route/method filtering doesn't include this method
Recommended solutions
  • Check API documentation for allowed methods
  • Add method support or update routes in backend
  • Correct request method in frontend
Client request is not acceptable.
The Accept header specifies content types the server cannot provide (e.g. image/avif).
Possible causes
  • Accept header doesn't match server's response types
  • Server doesn't support content negotiation
  • Accept header contains typos or syntax errors
Recommended solutions
  • Set Accept to server-supported types (e.g. application/json)
  • Implement content negotiation mechanism
  • Ensure correct Accept header format
Proxy authentication required.
This standard code indicates the client needs to provide credentials to the proxy server.
Possible causes
  • Request goes through authenticated proxy
  • Missing Proxy-Authorization header
Recommended solutions
  • Provide valid credentials to the proxy
  • Contact network administrator for authentication details
Server timed out waiting for the request.
Client failed to complete the request sending in time or network latency was too high.
Possible causes
  • Network latency or instability
  • Slow request body transmission
  • Server timeout setting is too short
Recommended solutions
  • Improve network stability or retry connection
  • Use chunked transfer or compression for large requests
  • Increase timeout settings on both server and client
Request conflicts with current resource state.
Examples include concurrent modifications, duplicate unique values, or transaction errors.
Possible causes
  • Concurrent operations causing version conflicts
  • Attempting to create duplicate resources (e.g. duplicate username)
  • Business logic conflicts
Recommended solutions
  • Use optimistic locking/version control
  • Check resource existence before creation
  • Manage conflicts using transactions or idempotent methods
Resource is permanently gone and no longer available.
Unlike 404, this status explicitly indicates the resource is deprecated with no migration.
Possible causes
  • API or resource has been deprecated
  • No alternative path available
Recommended solutions
  • Notify users about resource deprecation
  • Provide alternative solutions for users
  • Clean up invalid references in client
Missing Content-Length.
Server requires explicit request body length, but client didn't set it or the value doesn't match actual body.
Possible causes
  • Content-Length header is missing
  • Length value doesn't match actual body size
Recommended solutions
  • Set correct Content-Length header
  • Use chunked encoding or calculate exact length
Precondition failed.
Typically used when ETag, If-Match or other optimistic lock control conditions fail validation.
Possible causes
  • ETag or If-Match doesn't match
  • Resource was modified after being read
Recommended solutions
  • Get latest resource state and retry
  • Update conditional headers for optimistic control
Request payload too large.
Exceeds server's maximum accepted limit, commonly used for large file uploads or oversized JSON.
Possible causes
  • Uploading large files (images/videos) exceeding limit
  • Complex JSON request body too large
Recommended solutions
  • Use chunked upload or compress resources
  • Increase server's maximum size limit
  • Pre-check size before sending in frontend
URI too long.
Caused by GET requests with too many parameters or redirect chains making URI bloated.
Possible causes
  • GET request with excessive parameters
  • Redirect chains accumulating long URI
Recommended solutions
  • Switch to POST with request body
  • Avoid nested parameter concatenation
  • Clean up redirect loops
Unsupported media type.
Typically indicates Content-Type is not recognized or doesn't match by the server.
Possible causes
  • Content-Type doesn't match actual body
  • Server doesn't support this media type
Recommended solutions
  • Use correctly matched Content-Type
  • Extend server support for required formats
Range request is not satisfiable.
Requested range exceeds resource length or resource has changed causing mismatch.
Possible causes
  • Range exceeds resource length
  • File changes made the request invalid
Recommended solutions
  • Set valid Range parameters
  • Retry after getting updated resource length
Server cannot meet Expect header requirements.
Returned when Expect:100-continue is not supported.
Possible causes
  • Using Expect header when server doesn't support it
  • Exception in Expect header processing
Recommended solutions
  • Remove Expect header
  • Enable Expect support on server
Defined by IETF in RFC2324 (April Fools' RFC) as a joke.
Indicates 'I'm a teapot' that can't brew coffee, sometimes used to identify test/crawler requests. Not for formal use.
Possible causes
  • Client requested coffee brewing from a teapot (HTCPCP)
  • Developers or server intentionally returning this for testing/debugging
Recommended solutions
  • No action needed, just an Easter egg or test purpose
  • Return 403 instead if used for blocking
Laravel framework specific status code.
Indicates authentication timeout, commonly used when CSRF token expires or session times out. Not an official standard but widely used in web apps.
Possible causes
  • Expired or invalid CSRF token
  • User login session timeout
  • Browser missing authentication cookies
Recommended solutions
  • Prompt user to re-login or refresh page for new token
  • Frontend should ensure valid CSRF token in each request
  • Adjust server session timeout to meet requirements
Spring Framework (WebDAV) specific status code.
Indicates method execution failure, commonly used in WebDAV development when partial resource operations fail. Not an official HTTP standard code.
Possible causes
  • Method syntax correct but execution failed
  • Resource state or permissions caused operation failure
  • WebDAV operation conflicts or partial failures
Recommended solutions
  • Check resource state and permission configuration
  • Ensure WebDAV service handles methods correctly
  • Enhance error logging for troubleshooting
Request was directed to wrong server.
Common in HTTP/2 when multiple domains share same IP without proper routing.
Possible causes
  • TLS SNI points to server not supporting the Host
  • Multiple domains share IP without routing distinction
Recommended solutions
  • Configure proper TLS SNI and domain binding
  • Ensure HTTP/2 multi-domain service supports Host distinction
Request syntax correct but semantically invalid.
Commonly used for form/JSON validation failures like missing fields or illegal values.
Possible causes
  • Required fields missing or type mismatch
  • Field values failing business validation
Recommended solutions
  • Frontend validation and field completion
  • Submit compliant content following API specs
Resource is locked.
Used in WebDAV when resource is being modified or locked by another request.
Possible causes
  • Resource lock is held
  • Being modified by other user/system
Recommended solutions
  • Wait for lock release
  • Release lock or limit concurrent access
Current request failed due to dependency failure.
Common in WebDAV transaction scenarios where one failure causes subsequent failures.
Possible causes
  • Previous operation in transaction failed
  • Dependent request chain not fully executed
Recommended solutions
  • Check status of previous steps in chain
  • Break down process and retry failed steps
Server rejects premature requests.
Prevents clients from sending requests before TLS handshake completes to avoid replay attacks.
Possible causes
  • Client using early data to send requests
  • Browser or request library supports 0-RTT request strategy
Recommended solutions
  • Wait for TLS handshake completion before sending requests
  • Disable early request feature
Protocol upgrade required.
For example enforcing TLS or HTTP/2 for better security or performance.
Possible causes
  • Client using insecure or outdated protocols
  • Backend requires connection protocol upgrade
Recommended solutions
  • Use protocols like https or TLS/2
  • Server may provide Upgrade hint header
Server requires conditional request headers.
Prevents blind write operations that may cause lost updates.
Possible causes
  • Resources now require conditional headers for write operations
  • Optimistic locking not enabled
Recommended solutions
  • Add If-Match or If-Unmodified-Since headers to write requests
  • Ensure requests meet preconditions
Too many requests sent, triggering rate limiting.
Server usually provides Retry-After header indicating when to retry.
Possible causes
  • Client making too many concurrent or frequent API calls
  • IP or user reached quota limit
Recommended solutions
  • Follow Retry-After header for retries
  • Implement exponential backoff mechanism
  • Increase quota or limit concurrent requests when appropriate
Shopify custom status code.
Indicates request headers are too large, exceeding server size limits, often due to excessive cookies or custom headers.
Possible causes
  • Request carries too many/large cookies
  • Excessive custom headers or verbose content
  • Header data exceeds server processing capacity
Recommended solutions
  • Clean up or reduce cookies and headers
  • Optimize client requests by removing unnecessary headers
  • Increase server header size limit (if possible)
Request header fields too large.
Commonly caused by cookie bloat, excessive custom headers, or cyclic accumulation.
Possible causes
  • Too many/large cookies
  • Duplicate headers or excessively long header content
Recommended solutions
  • Remove unused cookies
  • Reduce number of header fields
  • Split headers logically
Non-standard code defined by Nginx.
Server closes connection immediately without response to prevent malicious/scraping requests.
Possible causes
  • Nginx configured with return 444 to block specific requests
  • Anti-scraping/scanning policy triggered
Recommended solutions
  • Verify blocking configuration accuracy
  • Analyze logs for false positives
  • Implement whitelist to avoid blocking legitimate traffic
Microsoft IIS custom status code.
Indicates request failed due to certain conditions, client should modify and retry. Used when proxies/servers require request adjustments.
Possible causes
  • Missing required headers/parameters
  • Request format doesn't meet server requirements
  • Server expects client to modify request
Recommended solutions
  • Modify request per server response hints
  • Add missing headers/parameters
  • Retry with compliant request
Microsoft IIS custom status code.
Indicates request was blocked by Windows Parental Controls, common in home networks or restricted enterprise environments.
Possible causes
  • Target blocked by parental control policies
  • Accessing restricted websites/content
  • User account has limited permissions
Recommended solutions
  • Contact network administrator to remove restrictions
  • Adjust parental control settings to allow access
  • Use account without permission restrictions
Resource unavailable due to legal restrictions.
Blocked for reasons like copyright, censorship or court orders.
Possible causes
  • Copyright disputes causing takedown
  • Government or court-ordered blocking
Recommended solutions
  • Display legal notice to avoid violation
  • Provide alternative information or legal access
Nginx non-standard status code.
Request headers exceed server size limits, causing rejection.
Possible causes
  • Too many/large cookies in request
  • Redundant or oversized custom headers
  • Client error causing header bloat
Recommended solutions
  • Clean up cookies and headers
  • Optimize header size to avoid redundancy
  • Adjust Nginx's client_header_buffer_size and large_client_header_buffers
Defined by Nginx.
Client provided invalid or untrusted SSL certificate, connection rejected.
Possible causes
  • Client SSL certificate has invalid signature or expired
  • Incomplete certificate chain or domain mismatch
Recommended solutions
  • Use valid trusted certificate
  • Configure complete certificate chain
Defined by Nginx.
Client didn't provide required SSL certificate while server is configured for mutual authentication.
Possible causes
  • Mutual TLS enabled but client lacks certificate
  • No certificate provided during SSL handshake
Recommended solutions
  • Attach valid client certificate
  • Or disable mutual authentication requirement
Defined by Nginx.
Client incorrectly used HTTP protocol to access HTTPS port, causing protocol mismatch.
Possible causes
  • Using http:// instead of https:// to access port 443
  • Incorrect URL configuration or port
Recommended solutions
  • Access using HTTPS protocol
  • Fix frontend/proxy URL configuration
Defined by Esri ArcGIS Server.
Indicates client token is invalid, revoked or malformed, distinct from generic 401.
Possible causes
  • Token signature verification failed or expired
  • Token format doesn't meet service requirements
Recommended solutions
  • Re-login or refresh token
  • Backend should provide detailed error for troubleshooting
Non-standard code defined by Nginx and Esri ArcGIS Server.
Client closed connection before server responded.
Common with user cancellations, network fluctuations or mobile network switching.
Possible causes
  • User actively stopped page loading or cancelled request
  • Mobile network switching/disconnection
  • Frontend request timeout or network interruption
Recommended solutions
  • Optimize API response speed to reduce blocking
  • Implement timeout and retry mechanism in frontend
  • Monitor 499 frequency to detect abnormal network conditions
Standard HTTP/1.0 server error.
Indicates the server encountered an unexpected condition.
Possible causes
  • Uncaught exception in backend code
  • Database connection failure or execution error
  • Third-party API response error
Recommended solutions
  • Improve exception handling mechanisms
  • Optimize database connection pool and retry logic
  • Add error logging and alert monitoring
Standard HTTP/1.1.
The server does not support the request method (e.g. PUT, PATCH or custom methods).
Possible causes
  • Requested HTTP method not implemented by server
  • Request strategy exceeds server capabilities
Recommended solutions
  • Check API documentation for supported methods
  • Implement required functionality or return 405
Standard HTTP/1.1.
Invalid response received from upstream server when acting as gateway/proxy.
Possible causes
  • Upstream server returned malformed content or error
  • Incorrect gateway connection/timeout settings
Recommended solutions
  • Verify gateway-upstream connection config
  • Implement timeout/retry mechanisms
  • Fix upstream service interface issues
Standard HTTP/1.1.
Server currently unable to handle requests (overloaded, maintenance or resource exhaustion).
Possible causes
  • Server overload (high QPS/resource contention)
  • Service maintenance or restart in progress
  • System resources (CPU/memory) exhausted
Recommended solutions
  • Implement health checks and request distribution
  • Use canary deployment to avoid version conflicts
  • Scale resources or implement rate limiting
Standard HTTP/1.1.
Upstream server didn't respond within configured timeout when acting as gateway/proxy.
Possible causes
  • Upstream service processing too slow or deadlocked
  • Network latency or connection issues
  • Proxy/load balancer timeout setting too short
Recommended solutions
  • Troubleshoot upstream performance bottlenecks
  • Set reasonable timeout duration
  • Optimize network connection stability
Standard HTTP/1.1.
Server doesn't support the HTTP version specified by client.
Possible causes
  • Client using unsupported HTTP version (e.g. HTTP/2 calling HTTP/1.0 service)
Recommended solutions
  • Client should use supported protocol version
  • Server may return upgrade hint or compatibility handling
WebDAV extension (RFC 2295).
Server configured variant negotiation proxy that itself participates in negotiation, causing circular dependency.
Possible causes
  • Server incorrectly includes itself as variant in content negotiation
  • Proxy/middleware configuration loop causing negotiation cycle
  • Incorrect multi-layer proxy setup creating request loop
Recommended solutions
  • Check server content negotiation config to avoid self-participation
  • Adjust proxy layer config to prevent circular calls
  • Optimize multi-proxy chain for correct forwarding
WebDAV extension (RFC4918).
Server cannot store content needed to complete the request (e.g. disk space exhausted).
Possible causes
  • Disk space exhausted
  • Resource write failure
Recommended solutions
  • Free up disk space or expand storage
  • Detect write errors and notify users
WebDAV extension (RFC5842).
Server detected an internal circular reference causing infinite recursion.
Possible causes
  • Circular reference in resource paths
  • No protection against circular dependencies
Recommended solutions
  • Detect and eliminate circular references in config
  • Add circular reference protection
Custom status code defined by Apache/cPanel.
Indicates server bandwidth limit reached, temporarily rejecting requests to prevent overload.
Possible causes
  • Server bandwidth exhausted or near limit
  • Traffic spikes causing server overload
Recommended solutions
  • Contact hosting provider to increase bandwidth
  • Optimize content delivery to reduce traffic spikes
  • Use CDN to share traffic load
HTTP extension status code (RFC 2774), indicates client request lacks required extension info.
This status is deprecated and not recommended.
Possible causes
  • Missing required extension headers/parameters
  • Server requires additional protocol extensions
Recommended solutions
  • Ensure client requests include all required extension info
  • Avoid deprecated protocol extensions or migrate to new ones
Standard status code (RFC 6585).
Client needs network authentication, common in Captive Portal scenarios like public WiFi login pages.
Possible causes
  • User hasn't authenticated through network portal
  • Restricted network access requiring authentication
Recommended solutions
  • Guide user through network authentication
  • Allow Captive Portal page access
  • Admin should ensure auth system works properly
Custom status code defined by Cloudflare.
Indicates origin server returned an unknown error or empty response, preventing Cloudflare from properly responding.
Possible causes
  • Origin server crashed or abnormally closed connection
  • Invalid or empty HTTP response returned
Recommended solutions
  • Check origin server logs for anomalies
  • Ensure server processes requests correctly and returns valid responses
Cloudflare custom code.
Cloudflare cannot connect to origin server - server is down or rejecting connections.
Possible causes
  • Origin server offline or unreachable
  • Firewall blocking Cloudflare IPs
Recommended solutions
  • Verify origin server is online and listening
  • Configure firewall to allow Cloudflare access
Cloudflare custom code.
TCP connection to origin succeeded but server didn't respond within timeout period.
Possible causes
  • Origin server responding too slowly
  • Network latency or congestion
Recommended solutions
  • Optimize server performance
  • Adjust timeout settings
Cloudflare custom code.
Cloudflare cannot reach origin server via DNS resolution, causing request failure.
Possible causes
  • DNS resolution errors or misconfiguration
  • Origin server network unreachable
Recommended solutions
  • Verify DNS record accuracy
  • Ensure origin server network connectivity
Cloudflare custom code.
Connection established but origin server didn't complete response within timeout.
Possible causes
  • Origin server request processing timeout
  • Long-running blocking operations
Recommended solutions
  • Optimize server processing logic
  • Avoid long-blocking requests
Cloudflare custom code.
SSL handshake between Cloudflare and origin failed, usually due to invalid certificate or misconfiguration.
Possible causes
  • Invalid or expired SSL certificate
  • Protocol mismatch or configuration error
Recommended solutions
  • Install valid SSL certificate
  • Configure correct TLS version
Cloudflare custom code.
Origin server provided invalid or untrusted SSL certificate.
Possible causes
  • Certificate expired, invalid signature or untrusted
Recommended solutions
  • Update and install valid certificate
  • Ensure complete certificate chain
Cloudflare custom code (Railgun service).
Railgun communication error between Cloudflare and origin server.
Possible causes
  • Railgun service unavailable or misconfigured
  • Version incompatibility
Recommended solutions
  • Check Railgun service status
  • Update or reset Railgun configuration
Non-standard code defined by Qualys SSL Labs.
Indicates server is too overloaded to handle requests.
Possible causes
  • Server resources exhausted
  • Traffic congestion from excessive requests
Recommended solutions
  • Scale up server resources
  • Implement traffic control and load balancing
Custom status code defined by Pantheon.
Indicates site is frozen due to policy violation and inaccessible.
Possible causes
  • Terms of service violation
  • Service suspension or freeze
Recommended solutions
  • Contact service provider to resolve
  • Comply with platform policies to restore service
Reserved for CDN/cloud vendors or manufacturers.
Meaning varies by provider, not officially registered with IANA/IETF.
Possible causes
  • Vendor-specific codes for product features
  • Commonly used for custom errors, traffic control, access restrictions
  • Some ranges reserved for AWS ELB, Cloudflare, Akamai etc.
Recommended solutions
  • Consult vendor documentation for definitions
  • Troubleshoot using error details and logs
  • Contact vendor support for resolution
Same as 531 - vendor-specific reserved code range.
Possible causes
  • See description for status 531
Recommended solutions
  • See description for status 531
Same as above.
Possible causes
  • See description for status 531
Recommended solutions
  • See description for status 531
Same as above.
Possible causes
  • See description for status 531
Recommended solutions
  • See description for status 531
Same as above.
Possible causes
  • See description for status 531
Recommended solutions
  • See description for status 531
Same as above.
Possible causes
  • See description for status 531
Recommended solutions
  • See description for status 531
Same as above.
Possible causes
  • See description for status 531
Recommended solutions
  • See description for status 531
Same as above.
Possible causes
  • See description for status 531
Recommended solutions
  • See description for status 531
Non-standard proxy error code.
Proxy server timed out when connecting to upstream server.
Possible causes
  • Upstream server unreachable
  • Network latency or failure
Recommended solutions
  • Check network connection and proxy config
  • Increase connection timeout
About Toolbox
We deliver smart, efficient web tools to simplify your work and life.
ICP License No.: 京ICP备18008190号-3
Privacy Policy