Outrings
Web observability and evidence

What third parties does my website load?

Finding every external origin your pages pull in, and why the list is almost always longer than you think.

4 min read
Short answer

Every external script, font, image, iframe and pixel is a third party you have given access to your visitors and, in the case of scripts, to your page. Most sites load between five and thirty such origins, and the owners are usually aware of about half.

What a third party actually gets

The exposure varies enormously by resource type, and the distinction is worth internalising because it determines how much a given inclusion should worry you.

ResourceWhat they receiveRisk
<script src>Full execution in your page: DOM, cookies, forms, keystrokesHighest. Equivalent to your own code.
<iframe>Its own context, the referrer, and an interface in your pageHigh
Fonts, images, CSSIP address, user agent, referrerModerate — a request log, not execution
Tracking pixelIP, user agent, referrer, plus whatever is in the URLModerate, and its entire purpose is identification
<link rel="preconnect">A connection, before anything is even requestedLow, but it is still contact

The first row is the one to take seriously. A third-party script is not "on" your page in the sense of a picture — it is running as your page, with everything that implies. If that provider is compromised, your site is compromised, and their security posture is now yours.

Finding them all

In a browser

Open devtools, the Network tab, reload, and sort by Domain. Everything that is not your own origin is a third party. Do this on several page types — the homepage rarely loads what the checkout page does.

From the HTML

curl -sL https://example.com \
  | grep -oE '(src|href)="https?://[^"]+' \
  | sed -E 's|.*//||; s|/.*||' \
  | sort -u

That lists origins referenced in the initial HTML. It will miss anything injected later by JavaScript, which is precisely how tag managers work — so treat it as a floor, not a total.

Why the list grows without anyone deciding

  • Tag managers. One container tag, and thereafter marketing can add vendors without touching your codebase. This is the single largest source of unknown third parties.
  • Vendors loading vendors. A chat widget that loads its own analytics, which loads a session recorder. Your one decision became three.
  • Embeds. A video, a map, a social post — each brings its own stack.
  • Abandoned experiments. An A/B tool trialled two years ago whose snippet is still in the template.
Point two is why an inventory beats a code review. Reading your own templates tells you what you included. Only observing the actual requests tells you what your inclusions included.

What each one costs you

  • Privacy and legal exposure. Under GDPR-style regimes, most third parties in this list require consent before loading. Loading them before consent — or loading ones nobody documented — is the common compliance failure.
  • Performance. Each new origin means a DNS lookup, a TCP connection and a TLS handshake before a single byte arrives.
  • Security. Your attack surface is the union of every provider's. Supply-chain compromises of analytics and widget vendors are a recurring event, not a hypothetical.
  • Availability. A render-blocking third-party script that hangs will hang your page.

Cleaning it up

  1. Inventory what is actually loading, across several page types rather than just the homepage.
  2. For each origin, name the person or team who needs it. Anything with no owner goes.
  3. Self-host what can be self-hosted — fonts especially, which are a pure request-log leak for no benefit.
  4. Load anything non-essential after consent, not before.
  5. Add Subresource Integrity to third-party scripts where the vendor supports stable versioned URLs.
  6. Re-inventory quarterly. The list regrows.

Step three alone often removes a third of the list, and self-hosted fonts are usually faster as well as more private.

What our audit reports about this

Every item below is measured directly, not inferred. Run it against your own site and the result names the exact rule or header responsible.

  • A complete inventory of every third-party origin the page requests, grouped by what kind of resource each one serves.
  • Which requests are scripts — the category with full access to your page — as distinct from passive resources.
  • Whether tracking or analytics loads before any consent mechanism, which is the common compliance failure.
  • Whether third-party scripts carry Subresource Integrity attributes.

For agents and scripts, the same measurement is at /api/v1/privacy?url=yoursite.com — see the API documentation.

Related questions

How many third parties is too many?

There is no threshold, but every one should have an owner who can say why it is there. In practice, sites that inventory properly usually remove between a quarter and a half on the first pass without anyone missing them.

Are fonts really a privacy issue?

Loading a font from a third-party origin sends every visitor's IP address and user agent to that provider on every page view. Self-hosting removes that entirely and is typically faster, since it avoids an extra connection setup.

What is Subresource Integrity?

A hash on the script tag, so the browser refuses to run the file if its contents change. It protects against a compromised or altered third-party file, and requires the vendor to serve stable versioned URLs rather than a rolling latest.

Does a tag manager count as one third party?

It counts as one in the inventory and behaves as an unbounded number in practice, because anything added through its interface loads without a code change. It is worth auditing separately from the rest.

Read next

All 100 guides · How every check works · API for agents