Can this page send your file anywhere?

Paste the address of any page that asks you for a file. Run the check in your own browser and find out whether that page is able to transmit what you give it — not whether it promises not to.

You pick the page

Any site that asks you for a file. We never see the address — it stays in the box on your device.

Your browser runs the check

Paste ten seconds of code into your own console. It attempts five deliberate connections and reports which the browser refused.

You read the result

A card on that page, showing what it is able to do with your file. Yours to keep, screenshot or ignore.

1 — Choose a page

Any site that asks you for a file.

Step one

Page address

We do not fetch it. Read why below: a site that fetched what you paste would be a site that receives what you paste.

2 — Run the check yourself

Ten seconds, in the browser you already have open.

Watch what the page actually does

1. Open the page in a tab.
2. Open DevTools and click Console. On most browsers that is F12, or ⌥⌘I on a Mac.
3. Paste the check, press Enter, then use the page normally.

/* Can this page send your file anywhere?  —  getopentools.com/proof/check
   Paste into DevTools › Console on the page you want to check, then press Enter.

   It reports nothing about you to anyone: no result leaves your browser. It
   does deliberately ATTEMPT five connections — four to a host that does not
   exist, one to a path on this site that does not exist — because the only way
   to know a browser refuses a connection is to have it refuse one. They carry
   the word 'probe' and nothing else. Everything stops when you reload.

   It is long because it is readable. You should be able to read anything you
   paste into a console, and a tool about trust is a poor place to start
   asking for some. */
(async () => {
  const PROBE = "https://egress-probe.invalid/probe";
  const here = location.host;
  const out = { policy: null, enforced: false, vectors: [], offOrigin: [], carried: [] };

  /* 1 — the policy, read out of a deliberate violation. A header cannot be read
        from script; the violation event carries the whole policy string. */
  const seen = await new Promise((resolve) => {
    let done = false;
    const onViolation = (event) => {
      if (done) return;
      done = true;
      resolve({ policy: event.originalPolicy || '', disposition: event.disposition || 'enforce', directive: event.effectiveDirective || '' });
    };
    document.addEventListener('securitypolicyviolation', onViolation, { once: true });
    try { fetch(PROBE, { mode: 'no-cors' }).catch(() => {}); } catch (e) {}
    setTimeout(() => { if (!done) { done = true; resolve(null); } }, 1200);
  });
  if (seen) { out.policy = seen.policy; out.enforced = seen.disposition !== 'report'; }

  /* 2 — five deliberate attempts. Watching an idle page proves only that
        nothing happened to fire; it never proves the control works. */
  const record = (name, refused, note) => out.vectors.push({ name, refused, note: note || '' });
  const violations = [];
  const collector = (e) => violations.push(e.effectiveDirective + '|' + e.disposition);
  document.addEventListener('securitypolicyviolation', collector);

  try { await fetch(PROBE, { mode: 'no-cors' }); record('fetch → third party', false, 'a request completed'); }
  catch (e) { record('fetch → third party', true, String(e.message || e).slice(0, 70)); }

  /* A same-origin POST, but NEVER to location.href: on a stranger's site that
     URL may be a real endpoint, and a probe that logs someone out or submits
     their form is not a probe. A path that cannot exist answers the same
     question -- whether the policy permits a body-carrying request at all --
     and a 404 is the worst it can do. */
  const SAME_ORIGIN_PROBE = location.origin + '/.egress-probe-' + Math.random().toString(36).slice(2);
  try { await fetch(SAME_ORIGIN_PROBE, { method: 'POST', body: 'probe' }); record('POST → this origin', false, 'a request completed'); }
  catch (e) { record('POST → this origin', true, String(e.message || e).slice(0, 70)); }

  await new Promise((resolve) => {
    try {
      const xhr = new XMLHttpRequest();
      xhr.open('POST', PROBE, true);
      xhr.onerror = () => { record('XMLHttpRequest', true, 'refused'); resolve(); };
      xhr.onload = () => { record('XMLHttpRequest', false, 'a request completed'); resolve(); };
      xhr.send('probe');
      setTimeout(resolve, 900);
    } catch (e) { record('XMLHttpRequest', true, String(e.message || e).slice(0, 70)); resolve(); }
  });

  try { const ws = new WebSocket('wss://egress-probe.invalid'); ws.close(); record('WebSocket', false, 'construction allowed'); }
  catch (e) { record('WebSocket', true, String(e.message || e).slice(0, 70)); }

  /* sendBeacon returns TRUE even when CSP refuses it — the spec returns true
     once the beacon is queued. Never assert on that boolean. Ask the policy. */
  try {
    /* Only violations raised AFTER this point count. Asking "did a connect-src
       violation happen" would be answered yes by the fetch probe above, and the
       check would report sendBeacon as refused without ever testing it -- a
       detector that passes without looking, which is the failure mode
       docs/EGRESS_PROOF.md was written about. */
    const before = violations.length;
    navigator.sendBeacon(PROBE, 'probe');
    await new Promise((r) => setTimeout(r, 250));
    const blocked = violations.slice(before).some((v) => v.indexOf('connect-src') === 0 || v.indexOf('default-src') === 0);
    record('navigator.sendBeacon', blocked, blocked ? 'refused by policy' : 'queued — the return value is never evidence');
  } catch (e) { record('navigator.sendBeacon', true, String(e.message || e).slice(0, 70)); }

  /* 3 — which third-party hosts this page has already contacted.
        Hosts, not bytes, are the headline. transferSize reads 0 for a
        cross-origin resource whose server sends no Timing-Allow-Origin header,
        which is most of them -- so "0 bytes" would be a measurement failure
        rendered as an all-clear, and this tool cannot afford that direction of
        error. The count of hosts is reliable; the byte figure is reported only
        where it is non-zero, and described as a floor. */
  for (const entry of performance.getEntriesByType('resource')) {
    const url = entry.name || '';
    if (url.indexOf('blob:') === 0 || url.indexOf('data:') === 0) continue;
    let host = '';
    try { host = new URL(url, location.href).host; } catch (e) { continue; }
    if (!host || host === here) continue;
    out.offOrigin.push({ host, bytes: entry.transferSize || 0 });
  }

  /* 4 — keep watching. Anything with a body can carry a file out, including to
        this page's own origin, which is the case CSP does not cover. */
  const note = (what) => { out.carried.push(what); console.warn('[egress] this page tried to send: ' + what); };
  const realFetch = window.fetch;
  window.fetch = function (input, init) {
    const url = typeof input === 'string' ? input : (input && input.url) || '';
    const method = ((init && init.method) || (input && input.method) || 'GET').toUpperCase();
    if (method !== 'GET' || (init && init.body)) note(method + ' ' + url);
    return realFetch.apply(this, arguments);
  };
  const realSend = XMLHttpRequest.prototype.send;
  XMLHttpRequest.prototype.send = function (body) {
    if (body) note('XHR with a body');
    return realSend.apply(this, arguments);
  };
  /* navigator.sendBeacon is read-only in some engines; a failed assignment
     must not take the rest of the check down with it. */
  try {
    const realBeacon = navigator.sendBeacon && navigator.sendBeacon.bind(navigator);
    if (realBeacon) navigator.sendBeacon = function (url, data) { note('sendBeacon ' + url); return realBeacon(url, data); };
  } catch (e) {}

  /* The verdict, by the same rule the site and the extension use. */
  const directives = {};
  for (const part of (out.policy || '').split(';')) {
    const t = part.trim(); if (!t) continue;
    const gap = t.search(/\s/); const name = (gap === -1 ? t : t.slice(0, gap)).toLowerCase();
    if (!(name in directives)) directives[name] = gap === -1 ? '' : t.slice(gap + 1).trim();
  }
  let source = directives['connect-src'];
  let viaDefault = false;
  if (source === undefined) { source = directives['default-src']; viaDefault = true; }
  let verdict;
  if (!out.policy || source === undefined) verdict = 'CAPABLE';
  else if (source === '' || /^'none'$/i.test(source.trim())) verdict = 'BLOCKED';
  else verdict = 'RESTRICTED';
  if (!out.enforced && verdict === 'BLOCKED') verdict = 'CAPABLE';

  const bytes = out.offOrigin.reduce((sum, e) => sum + e.bytes, 0);
  const hosts = out.offOrigin.map((e) => e.host).filter((h, i, all) => all.indexOf(h) === i);
  const copy = {
    BLOCKED: ['This page cannot send your file anywhere.', 'The browser refuses every connection it attempts' + (viaDefault ? ', through its default-src fallback' : '') + '. That is enforcement, not a promise.'],
    RESTRICTED: ['This page can send to a named list of destinations.', 'Connections are limited' + (viaDefault ? ' by default-src' : '') + ', but not switched off: ' + String(source).slice(0, 90)],
    CAPABLE: ['This page is able to send your file.', 'No policy stops it connecting anywhere.' + (out.policy && !out.enforced ? ' A report-only policy is declared, which the browser does not enforce.' : '')],
  }[verdict];

  /* An overlay rather than console text, because a result worth showing someone
     has to survive being screenshotted with the address bar in frame. */
  const tone = { BLOCKED: '#10b981', RESTRICTED: '#f59e0b', CAPABLE: '#f87171' }[verdict];
  document.getElementById('egress-check-card')?.remove();
  const card = document.createElement('div');
  card.id = 'egress-check-card';
  card.setAttribute('style', 'position:fixed;z-index:2147483647;top:16px;right:16px;width:380px;max-width:calc(100vw - 32px);background:#0b0f19;color:#e5e7eb;font:14px/1.5 ui-sans-serif,system-ui,-apple-system,Segoe UI,Roboto,sans-serif;border:1px solid #1f2937;border-radius:14px;box-shadow:0 20px 50px rgba(0,0,0,.45);overflow:hidden');
  const esc = (s) => String(s).replace(/[&<>"]/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;' }[c]));
  const rows = out.vectors.map((v) => '<div style="display:flex;gap:8px;padding:3px 0"><span style="color:' + (v.refused ? '#10b981' : '#f87171') + '">' + (v.refused ? '✓' : '!') + '</span><span style="flex:1">' + esc(v.name) + '</span><span style="color:#6b7280;font-size:12px">' + (v.refused ? 'refused' : 'allowed') + '</span></div>').join('');
  card.innerHTML =
    '<div style="padding:14px 16px;border-bottom:1px solid #1f2937;display:flex;align-items:center;gap:8px">' +
      '<span style="width:8px;height:8px;border-radius:50%;background:' + tone + '"></span>' +
      '<strong style="font-size:13px;letter-spacing:.02em">' + esc(here) + '</strong>' +
      '<button id="egress-check-close" style="margin-left:auto;background:none;border:0;color:#6b7280;cursor:pointer;font-size:18px;line-height:1">×</button>' +
    '</div>' +
    '<div style="padding:16px">' +
      '<div style="color:' + tone + ';font-size:17px;font-weight:600;margin-bottom:6px">' + esc(copy[0]) + '</div>' +
      '<div style="color:#9ca3af;font-size:13px;margin-bottom:14px">' + esc(copy[1]) + '</div>' +
      '<div style="border-top:1px solid #1f2937;padding-top:12px">' + rows + '</div>' +
      '<div style="border-top:1px solid #1f2937;margin-top:12px;padding-top:12px;color:#9ca3af;font-size:12.5px">' +
        esc(
          out.offOrigin.length === 0
            ? 'No third-party host was contacted while this page loaded.'
            : hosts.length + ' third-party host' + (hosts.length === 1 ? '' : 's') + ' contacted: ' + hosts.slice(0, 4).join(', ') + (hosts.length > 4 ? ', and ' + (hosts.length - 4) + ' more' : '') + (bytes > 0 ? ' — at least ' + bytes + ' bytes' : '')
        ) +
      '</div>' +
      '<div style="margin-top:10px;color:#6b7280;font-size:11.5px">' +
        (verdict === 'BLOCKED' ? 'Capability only. It says nothing about bugs.' : 'Able to send is not the same as does send. Server-side processing is a normal, legitimate design.') +
        '<br>Now use the page. Anything it tries to send is logged to the console.' +
      '</div>' +
    '</div>';
  document.body.appendChild(card);
  card.querySelector('#egress-check-close').onclick = () => card.remove();

  console.log('%c' + copy[0], 'color:' + tone + ';font-size:15px;font-weight:600');
  console.table(out.vectors);
  window.__egressCheck = out;
  return out;
})();

No result leaves your browser, and everything stops when you reload. It does deliberately attempt five connections to addresses that do not exist, carrying the word probe and nothing else — because the only way to know a browser refuses a connection is to watch it refuse one. Watching an idle page proves that nothing happened to fire, never that the control works.

It is long because it is readable. You should be able to read anything you paste into a console, and a tool about trust is a poor place to start asking for some.

Or read the policy from a terminal

Enter a page address above to build the command.

Paste whatever it prints into the box below. So will anything you copy from DevTools → Network → Headers.

3 — Read the verdict

Paste the headers. The answer is worked out on this device.

Why we do not just check it for you

Because a site that fetched the address you paste would be a site that receives the address you paste — a list of what strangers are suspicious of, held by us. Every page here is served a policy that switches off network connections entirely, and that policy is what the rest of this site's evidence rests on. Relaxing it to build this one page would mean breaking the proof in order to ship the tool that demonstrates it.

There is also no way around it: a browser cannot read another site's response headers without that site's permission. So the check runs where it can — in your browser, on the page you chose — and it turns out to be the stronger test. Reading a header tells you what a page declares. Watching it tells you what it does once it is holding your file.

What the four answers mean

Answer	Policy	Means
Cannot send	connect-src 'none'	The browser refuses every connection the page attempts. Enforcement, not a promise — it holds even against a bug in the page.
Restricted	a source list	Connections are limited to named destinations, but not switched off.
Able to send	no restriction	Nothing stops the page connecting. Most sites are here, and most of them say so.
Unknown	no policy read	The check could not read a policy. Not a finding, and never rendered as one.

What this does not tell you

Able to send is not the same as does send. Processing files on a server is a normal, legitimate and common design. Most products built that way describe it openly. What has been missing is any way for you to tell which kind of page you are on.
It is not a security audit. This reports where bytes are permitted to go. No egress measurement can establish that a page has no flaw, and none is claimed here.
It is a snapshot. It describes the page as served to you, now. A page can be served differently tomorrow, or to someone else.
Unknown is not a failure. Some servers refuse automated requests, which says nothing at all about their headers. An unreadable policy is reported as unread.

Where the check comes from

It is the same protocol this site runs against itself before every release that repeats an egress claim — the five deliberate exfiltration attempts, the off-origin byte count, and the rule that a request carrying a body is watched even when it points at the page's own origin, which a content-security policy does not cover. The run against this site sets out the method and the result, including what it does not establish.