HTTP 506 Variant Also Negotiates (RFC 2295) indicates that transparent content negotiation for the request results in a circular reference — the server's chosen variant is itself configured to engage in content negotiation, creating an infinite loop. This is a server configuration error, not a client error. It's extremely rare in practice and indicates a misconfigured content negotiation setup.
Response includes the status code, standard headers (including Content-Type), and a small diagnostic JSON body describing the request and returned status.
Simulator URL (copy in the app after load — not a normal link):
https://httpstatus.com/api/status/506
Example request:
curl -i "https://httpstatus.com/api/status/506"Transparent content negotiation for the request results in a circular reference.
On this code, Inspector focuses on semantics, headers, and correctness warnings that commonly affect clients and caches.
HTTP 506 Variant Also Negotiates represents a specific server-side condition that requires different handling than other 5xx errors. Understanding the precise cause helps operations teams diagnose and resolve issues faster. Monitoring systems should distinguish 506 from other 5xx codes for accurate alerting and diagnosis.
// Handle 506 Variant Also Negotiates
process.on('unhandledRejection', (reason) => {
console.error('Unhandled rejection:', reason);
});
app.use((err, req, res, next) => {
console.error(`${req.method} ${req.url}:`, err.stack);
res.status(err.status || 500).json({
error: process.env.NODE_ENV === 'production'
? 'Internal Server Error'
: err.message,
requestId: req.id
});
});from fastapi import FastAPI, Request
from fastapi.responses import JSONResponse
import logging
logger = logging.getLogger(__name__)
@app.exception_handler(Exception)
async def server_error_handler(request: Request, exc: Exception):
logger.error(f'{request.method} {request.url}: {exc}',
exc_info=True)
return JSONResponse(
status_code=506,
content={'error': 'Variant Also Negotiates', 'request_id': request.state.id}
)@ControllerAdvice
public class GlobalErrorHandler {
private static final Logger log = LoggerFactory.getLogger(
GlobalErrorHandler.class);
@ExceptionHandler(Exception.class)
public ResponseEntity<ErrorResponse> handleException(
Exception ex, HttpServletRequest req) {
log.error("{} {}: {}", req.getMethod(),
req.getRequestURI(), ex.getMessage(), ex);
return ResponseEntity.status(506)
.body(new ErrorResponse("Variant Also Negotiates",
"An unexpected error occurred"));
}
}func errorMiddleware(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
defer func() {
if err := recover(); err != nil {
log.Printf("%s %s: %v\n%s",
r.Method, r.URL, err, debug.Stack())
w.WriteHeader(506)
json.NewEncoder(w).Encode(map[string]string{
"error": "Variant Also Negotiates",
})
}
}()
next.ServeHTTP(w, r)
})
}