What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
Some links on this page are affiliate links: if you buy through them we may earn a commission, at no extra cost to you.
HTTP 506 (Variant Also Negotiates) is a server-side configuration error in HTTP Transparent Content Negotiation (TCN). It means the server selected a representation for your request, but that representation is itself configured to negotiate another representation. The selected resource is therefore not a terminal endpoint, so the server cannot complete the negotiation safely.
Start by inspecting the variant selected for the original URI, its type map or equivalent negotiation configuration, and whether requesting that variant invokes negotiation again. Changing a browser’s Accept header is not normally the primary fix.
| # | Preview | Product | Price | |
|---|---|---|---|---|
| 1 |
|
High Performance Browser Networking: What every web developer should know about networking and web... | $31.84 | Buy on Amazon |
| 2 |
|
Learning HTTP/2: A Practical Guide for Beginners | $18.11 | Buy on Amazon |
| 3 |
|
HTTP: The Definitive Guide | $26.04 | Buy on Amazon |
| 4 |
|
HTTP Pocket Reference: Hypertext Transfer Protocol | $6.94 | Buy on Amazon |
| 5 |
|
HTTP/2 in Action | $49.99 | Buy on Amazon |
What HTTP 506 means
The status phrase “Variant Also Negotiates” comes from RFC 2295, Transparent Content Negotiation in HTTP. In this protocol, one URI can have several representations, or variants—for example, different languages or media formats. The server (and, in transparent negotiation, the client working with the server) chooses the best representation using the available variant metadata and client preferences.
Recommended Free Tools
A 506 occurs when the representation chosen as “best” is not a finished response. It is itself marked as capable of negotiating. The server would have to negotiate again, creating a recursive selection path rather than returning a terminal representation.
#1 Best Overall
- Used Book in Good Condition
RFC 2295 section 8.1 describes the sequence: after generating a response for the best variant, the origin server checks the response for a TCN header. If that header is present, the best-variant resource is not a proper endpoint in the transparent-negotiation process, and a 506 response should be generated instead of continuing. The RFC is an Experimental specification published in March 1998; the protocol definition is not specific to any country or geography.
How the failure happens
Normal server-driven negotiation
In ordinary server-driven negotiation, a client sends preferences such as Accept or Accept-Language, and the server chooses a representation. Apache documents support for these common request headers. A mismatch or lack of a suitable representation is not automatically a 506.
Transparent negotiation
Transparent negotiation, defined by RFC 2295, lets the client and server collaborate using a variant list and related protocol elements. The selected representation must ultimately be a resource that can be returned directly.
Windows Errors? Fix Them Before They Spread
Repair common Windows errors and clear accumulated junk for a smoother, more stable PC - no reinstall needed.Free scan · no reinstallOutdated Drivers Are Slowing You Down
One free scan finds every outdated or missing driver and matches the right update for your exact hardware.Free scan · exact hardware matchThe recursive configuration
Suppose a language map selects a French resource. If that French resource is actually another type map, or is otherwise configured to perform transparent negotiation, the server has selected a negotiator instead of content. Negotiation points back into negotiation and the server emits 506.
Rank #2
MDN’s illustrative response includes TCN: list, Vary: negotiate,accept-language, and an Alternates entry pointing to a type map. Those headers describe the documented example; every real 506 response does not have to contain exactly that combination.
What to check first
- Confirm the status at the origin. Record the requested URI, response status, response headers, and the server or proxy that generated the response. A CDN, reverse proxy, or application gateway may be the layer returning the status, but 506 alone does not identify which layer.
- Identify the selected variant. Follow the negotiation metadata for the original URI. Look for the representation chosen for the request’s language, media type, or other preference.
- Inspect that representation’s configuration. Determine whether it is a static, terminal resource or a type map/negotiated resource. Check aliases, rewrite rules, include directives, and per-directory negotiation settings that could turn the selected path into another negotiation entry point.
- Trace one more request. Ask what happens when the selected variant is requested directly. If it returns another
TCNheader or invokes a second variant selection, you have found the recursive condition. - Fix the mapping, then retest. Point the original variant map at a terminal representation, or remove transparent negotiation from the selected resource. Retest with the same request headers and with a second language or media preference to ensure the map is not broken for only one case.
This is a diagnostic direction rather than a universal, version-independent repair recipe. The exact directive names and file layout depend on the server and deployment.
Apache-specific investigation
The Apache HTTP Server 2.5 trunk content-negotiation documentation describes ordinary server-driven negotiation and transparent negotiation, which Apache labels experimental. Do not assume that trunk documentation or directive behavior applies unchanged to every historical Apache release.
Review the relevant files and directives
- Locate the negotiated resource’s type map (commonly a
.varmap) and verify that each entry resolves to an actual representation rather than another map. - Check whether
MultiViews, explicit type maps, or rewrite rules cause the selected filename to be negotiated again. - Inspect directory-level and virtual-host configuration. A setting inherited from a parent directory can make a resource negotiable even when the local file appears ordinary.
- Review response headers in an uncompressed, direct-origin request so that an intermediary does not hide the
TCN,Alternates, orVaryclues.
After changing configuration, reload or restart the affected service according to your operational procedure, then clear any intermediary cache that could preserve the old response. The sources establish the recursive negotiation condition, not a single Apache command sequence.
Rank #3
Headers that help—and headers that do not
TCN
The presence of a TCN header in the response generated for the selected variant is the central RFC 2295 signal. It indicates that the selected resource participates in transparent negotiation.
Alternates
An Alternates header can describe available variants. Follow its entries to see whether the chosen path leads to a type map or another negotiable resource.
Vary
Vary tells caches which request fields affect selection. MDN’s example uses Vary: negotiate,accept-language. Treat that exact combination as an example, not a mandatory signature.
Accept and Accept-Language
These headers express client preferences in ordinary server-driven negotiation. Trying different values can help reproduce which variant is selected, but changing them does not repair a server resource that negotiates again. Use such tests to isolate the mapping, not as the permanent fix.
Rank #4
Reproducing and inspecting a 506 response
Capture the complete exchange against the origin when possible. For example:
curl -i -H 'Accept-Language: fr' https://example.com/pageThen request the suspected variant directly:
curl -i https://example.com/path/to/selected-variantCompare status and headers, especially TCN, Alternates, and Vary. If the direct request triggers negotiation again, inspect the map or rewrite that produced it. Use a request that bypasses your CDN only when your deployment permits it; do not expose private origin endpoints publicly.
Common symptoms and fixes
| Symptom | Likely cause | Action |
|---|---|---|
| 506 appears for one language only | That language’s map entry points to a negotiable resource | Compare the failing entry with a working language entry and point it to a terminal representation. |
| Every negotiated request returns 506 | The common best-variant target is itself a type map or negotiation endpoint | Inspect the shared map, aliases, and inherited directory settings. |
| Direct file request also returns 506 | The file path is being rewritten or negotiated again | Trace rewrite and content-negotiation rules for that directory. |
| Origin succeeds but public URL returns 506 | A proxy, CDN, or gateway is generating or caching the response | Compare origin and edge headers and identify which layer owns the status. |
Changing Accept appears to “fix” it temporarily |
A different variant avoids the recursive entry | Correct the faulty variant; do not rely on a client-specific header workaround. |
| No useful negotiation headers are visible | An intermediary removed or replaced them | Inspect a direct-origin response and review intermediary header policies. |
What HTTP 506 is not
- It is not a generic “content type unsupported” response. A client preference that has no match does not by itself create 506.
- It is not primarily a browser-cache or cookie problem. The specified condition is in origin-side transparent negotiation.
- It is not proof that Apache, a CDN, or a particular framework is responsible. The status identifies a negotiation configuration class, not the emitting component.
- It is not evidence that every response containing
Varyis faulty.Varyis widely used for cache correctness; 506 depends on the selected variant being negotiable again.
Reliability and deployment considerations
Test every selection dimension
After repairing one map entry, test each supported language and media preference. A configuration can be terminal for one variant and recursive for another.
The Tool Desk
Outbyte PC Repair FREEClear out junk files and repair common Windows errorsFree Scan →Outbyte Driver Updater FREEFix the driver behind crashes, sound loss and screen glitchesFind Drivers →Keep cache behavior aligned
Negotiation metadata affects cache keys. Verify that your proxy honors the relevant Vary fields and does not cache an error response for requests that should select a different representation.
Best Value
Separate origin and edge diagnosis
Record timestamps, request IDs, and response headers at both layers. A successful origin test does not rule out an edge rule that rewrites or caches the public response.
Roll back safely
Keep the previous map and configuration available, validate syntax before reload, and make changes in a maintenance window appropriate to your service. If the change increases errors, restore the last known-good mapping and invalidate only the affected cache entries.
Document the incident
For a useful handoff, save the original URI, request preference headers, selected variant, complete response headers, map or rewrite rule that selected it, and the result of requesting that variant directly. This evidence lets another administrator distinguish a recursive map from an intermediary-generated status without guessing.
Quick wins for a faster PC:
Repair Windows errors before they cause bigger problemsFix Now →Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →Clear out junk files and repair common Windows errorsFree Scan →Or skip the browser setup
If you need a visual record of the public response while diagnosing an edge-versus-origin difference, ScreenshotNeo can capture a URL through one API request. It accepts consent banners before capture and removes more than 60 known consent platforms, newsletter popups, and chat widgets; bot checks or CAPTCHAs, blank pages, timeouts, failed loads, and cache hits are not billed, and each response reports the page verdict and billing state in X-Page-Verdict and X-Billed headers. Its MCP server provides take_screenshot, get_page_info, and capture_pdf tools for Claude, Cursor, and other MCP clients.
cURL (see the ScreenshotNeo documentation):
curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://example.com/page -o shot.webpPython:
import requests
r = requests.get("https://api.screenshotneo.com/v1/shot", params={"access_key": "YOUR_API_KEY", "url": "https://example.com/page"}, timeout=90)
open("shot.webp", "wb").write(r.content)Node.js:
const q = new URLSearchParams({ access_key: 'YOUR_API_KEY', url: 'https://example.com/page' });
const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);
The Free plan includes 1,000 screenshots per month with no card; paid plans start at $5 for 3,000 shots. Create a free ScreenshotNeo account.
Frequently Asked Questions
Can a client force a 506 response with an Accept header?
The client header can influence which variant is selected, but 506 requires the selected variant to negotiate again. The corrective work is normally in the server’s variant mapping or negotiation configuration.
Is HTTP 506 the same as HTTP 406 Not Acceptable?
No. 406 concerns the server’s inability to provide an acceptable representation for the request. 506 identifies a recursive transparent-negotiation configuration in which the selected variant is itself negotiable.
Do these 3 things before closing this tab:
1Repair Windows errors before they cause bigger problems2Scan for outdated or missing drivers - takes under a minute3Clear out junk files and repair common Windows errorsDoes RFC 2295 require every 506 response to include Alternates?
No. MDN’s headers are an illustrative example. The defining condition is that the response generated for the best variant contains the transparent-negotiation signal and the selected resource is not a terminal endpoint.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
