Cross-Origin-Resource-Policy: what CORS skips
A response can carry Access-Control-Allow-Origin: *, pass every CORS check a browser runs, and still get blocked for an unrelated reason. Cross-Origin-Embedder-Policy (COEP) and Cross-Origin-Resource-Policy (CORP) run a second, independent check that CORS headers don't satisfy, and the failure looks enough like a CORS error that it sends people debugging the wrong header. We built two local origins, turned on COEP, and watched a wildcard-CORS image get blocked anyway, then watched one more header fix it.
What Cross-Origin-Resource-Policy checks that CORS doesn't
Access-Control-Allow-Origin and the rest of the CORS headers answer one question: can the page's script read the response body of a cross-origin request? Cross-Origin-Embedder-Policy and Cross-Origin-Resource-Policy answer a different one: should this resource be loaded cross-origin at all, including in contexts like <img> or <script> tags that never ask CORS a question in the first place. A document that sends Cross-Origin-Embedder-Policy: require-corp tells the browser to block every cross-origin subresource that doesn't carry a Cross-Origin-Resource-Policy header naming it eligible. Per MDN, the header takes one of three values: same-origin, same-site, or cross-origin, each a progressively looser boundary on who's allowed to load the resource. None of that is CORS. A resource can be CORS-enabled for every origin on the internet and still have no opinion on CORP, and under require-corp that silence is treated as a block, not as permission.
What we tested
We stood up two plain Node HTTP servers on different local ports. One serves a 1x1 PNG and accepts a query parameter that controls whether it sends a Cross-Origin-Resource-Policy header, and which value. The other serves an HTML page that embeds that image with a plain <img> tag, an ordinary no-cors load, the kind nothing about CORS would ever touch:
// served from the document origin
res.writeHead(200, {
'Content-Type': 'text/html',
'Cross-Origin-Embedder-Policy': 'require-corp',
'Cross-Origin-Opener-Policy': 'same-origin'
});
res.end(`<img id="pic" src="http://localhost:PORT/img.png?corp=cross-origin" />`);
We loaded the page in Playwright's bundled Chromium (version 153.0.8010.12, same build we used for an earlier browser test) and read back whether the image's load or error event fired, across three runs that varied only the image response's Cross-Origin-Resource-Policy header:
CORP header sent by the image | result
-----------------------------------|----------
(none) | blocked
Cross-Origin-Resource-Policy: same-origin | blocked
Cross-Origin-Resource-Policy: cross-origin | loaded
The image server never sent an Access-Control-Allow-Origin header at all in this test, and it didn't need to: an <img> tag's default load is a no-cors request, which was never going to check CORS headers either way. What decided whether the image loaded was Cross-Origin-Resource-Policy alone, read against the document's require-corp. same-origin wasn't enough, because the request was genuinely cross-origin (a different port counts as a different origin); only cross-origin, the value that means "any origin may load this," got the image through.
crossOriginIsolated doesn't track whether resources actually load
We also read self.crossOriginIsolated from the page in all three runs, since that flag is what gates access to SharedArrayBuffer and a handful of other APIs. It came back true every time, including the two runs where the image was blocked. The flag reflects the top document's own Cross-Origin-Opener-Policy and Cross-Origin-Embedder-Policy, set once when the page loads; it doesn't wait to see whether every subresource on the page actually clears the CORP check. A page can be fully cross-origin isolated and still have broken images, fonts, or iframes scattered through it, because isolation and per-resource loading are two separate outcomes of the same two headers, not one guarantee that implies the other.
Why a CORS proxy doesn't fix this on its own
If you're pulling a third-party image, font, or script through a proxy because the origin server doesn't send CORS headers, the proxy's Access-Control-Allow-Origin: * solves the problem you went looking for help with, and does nothing about COEP. The response your page actually receives is the proxied one, and require-corp checks that response's headers, not the original server's. If the upstream never sent Cross-Origin-Resource-Policy and the proxy doesn't add one, the resource is still blocked on a COEP page, same as our test, just with an extra hop in front of it.
corsproxy.dev doesn't set Cross-Origin-Resource-Policy on proxied responses by default, and it doesn't add Cross-Origin-Embedder-Policy or Cross-Origin-Opener-Policy to anything either; those are headers your own page sends about itself, not something a proxy for someone else's API should be deciding for you. What it does let you do is add the header yourself with a resHeaders override on the request, the same per-request mechanism covered in forwarding cookies through a proxy:
curl "https://api.corsproxy.dev/proxy?url=https%3A%2F%2Fexample.com%2Fimg.png&key=sk_live_...&resHeaders=Cross-Origin-Resource-Policy:cross-origin"
Cross-Origin-Resource-Policy isn't on the list of response headers resHeaders refuses to touch. That list exists for a reason: it can't set Set-Cookie, and it can't touch anything starting with access-control-, both covered in Access-Control-Expose-Headers, explained. A header about cross-origin resource loading falls outside both restrictions, so it passes through to the browser the way you set it.
The tradeoff is the same one MDN documents for the header generally: setting cross-origin means any site can load that resource in a no-cors context, the same openness a public CDN asset already has. That's a reasonable choice for a public image or font you're fronting through the proxy anyway. It's not a setting to reach for on a response carrying anything you'd rather keep inside an allowlisted set of origins, which is a different problem than CORP solves. One header the proxy won't let you touch either way is Content-Security-Policy: every response leaves corsproxy.dev with sandbox; default-src 'none' set, so a proxied page can never execute as a document on our origin, and resHeaders can't override that one.
What this doesn't change
None of this has anything to do with Content Security Policy, which governs what a page itself is allowed to load and run, not what cross-origin responses are allowed to be read by others. It's also unrelated to the same-origin policy that CORS exists to relax: COEP and CORP are an opt-in on top of it, not a replacement, and a page with no COEP header at all behaves exactly as it always did, loading cross-origin images and scripts the way the web has worked since before CORS existed. You only run into any of this once something on your page, usually a dependency that wants SharedArrayBuffer or precise timers, asks for cross-origin isolation and sets require-corp to get it.