Deep dive

The CORS wildcard already covers Authorization

We wrote in October that Access-Control-Allow-Headers: * has one exception: it doesn't cover Authorization, which has to be listed by name regardless. That's what the Fetch spec says. It isn't what current browsers do. We built a two-origin test page, pointed Chromium at it, and watched a wildcard preflight let an Authorization header through anyway. A WHATWG issue open since April says Firefox and Safari don't enforce the exception either, and a Mozilla engineer has said Firefox is ready to drop it for good.

· ~6 min read

The rule as written, and as we described it

The Fetch spec's CORS-preflight check treats * in Access-Control-Allow-Headers as covering every header the request wants to send, with Authorization carved out as a named exception: a preflight response has to list it explicitly, a bare wildcard doesn't count. We stated that rule plainly in fixing the Access-Control-Allow-Headers error: "Authorization is never covered by * and has to be listed by name regardless." That post is getting a correction alongside this one, because the rule it describes isn't what ships.

What we tested

We stood up two plain Node HTTP servers on different ports, so a browser treats them as different origins. One answers every request, including the preflight OPTIONS, with Access-Control-Allow-Headers: * and nothing more specific. The other serves a page that calls the first with fetch, setting an Authorization header and no credentials option:

// served from http://localhost:8092, fetching http://localhost:8091
const r = await fetch('http://localhost:8091/orders', {
  headers: { Authorization: 'Bearer test-token-123' }
});
const body = await r.json(); // { ok: true, gotAuth: 'Bearer test-token-123' }

The "API" server's only CORS-relevant headers on both the preflight and the real response are these three:

Access-Control-Allow-Origin: http://localhost:8092
Access-Control-Allow-Methods: GET, POST
Access-Control-Allow-Headers: *

We loaded the page in Playwright's bundled Chromium (version 153.0.8010.12 as of this test) and read back the result of the fetch call. The request succeeded: status 200, with gotAuth showing the server received the Authorization header. By the written spec, the preflight should have failed the request before it ever left the browser, because the wildcard doesn't name Authorization. It didn't. We only tested Chromium ourselves; we didn't independently verify Firefox or Safari, which is where the open issue below comes in.

The open WHATWG issue

Fetch spec issue whatwg/fetch#1919, titled "Disallowing Authorization in CORS-preflight wildcards is currently not web compatible," was opened on April 7, 2026. The report states the same gap directly: "The current spec disallows this, but Firefox, Chrome and Safari allow it." A related web-platform-tests change (PR 59369) added preflight cache coverage for the case later that month, and in August a Servo contributor reported that Servo's spec-compliant implementation fails real sites specifically because it enforces the exception that Firefox, Safari, Chrome, and Ladybird don't.

On August 31, 2026, Mozilla's valenting wrote that Firefox could ship the change today: "Firefox is happy to make this change (it's only a pref flip for us)," followed by the reason it hasn't: "we can only roll this out in step with the other major browser[s]." As of this post, the issue is still open, with no merged spec text and no announced rollout date from any engine.

What this changes in practice

If you're relying on the old rule, nothing breaks: explicitly listing Authorization in Access-Control-Allow-Headers still works everywhere, spec or no spec, and it's the version every current test suite and reviewer will expect. What changes is the other direction: if a server you don't control answers preflights with a bare wildcard and you assumed that would reject an Authorization header in the browser, don't rely on that assumption. It didn't hold in our test, and the spec text that would make it hold is the part being argued over in the open issue, not something enforced today.

This doesn't touch anything about credentialed requests. A wildcard Access-Control-Allow-Origin is still incompatible with credentials: 'include', cookies or TLS client certs, regardless of what Access-Control-Allow-Headers says; that's a separate check covered in CORS with cookies and credentials. Our test used no credentials at all, which is exactly the uncredentialed case the spec's Authorization exception is supposed to apply to.

Where this leaves corsproxy.dev

corsproxy.dev's own preflight response never uses a wildcard for Access-Control-Allow-Headers; it lists Content-Type, Authorization, and X-API-Key by name, so none of this changes how a browser call through the proxy behaves. If you're writing your own server's CORS handling and currently lean on the wildcard-plus-explicit-Authorization combination from our October post, that combination is still correct and still the one to ship; this post is about what happens if you drop the explicit listing and lean on the wildcard alone, which is a gap you'd only hit by accident, not a change we're recommending.

Checking it yourself

The only reliable way to see this is a browser, not curl: CORS is enforced by the fetching client, so a command-line request will get the same bytes back from the server whether or not a real browser would have blocked it. If you want to reproduce our result, serve a wildcard-only preflight response from one origin and call it with a credential-free fetch carrying an Authorization header from a second origin, then read response.status in the page, the way our test script above does.