For teams answering for their trackers

List every outside domain a page contacts on a first visit

Load a page as a brand-new visitor and get the list of every outside domain it contacted before anyone clicked anything.

Get your free API key Try the playground

The problem

A tag manager, three analytics tools, an A/B testing script and a chat widget, plus whatever each of them loads in turn. Nobody has a current list, the privacy notice was written against last year's, and the question that matters most, what loads before a visitor has agreed to anything, is the hardest one to answer from inside the code base.

How domscout handles it

Every capture starts in a fresh browser with no cookies, so it sees what a first-time visitor's browser does before consent. With diagnostics on, analysis.diagnostics.summary.thirdPartyDomains lists every host other than the page's own that served a response or a resource, and the response and resource lists give each URL with its type and transfer size. A subdomain of your own site, such as cdn.example.com, is a different host and appears in the list too. The result is a record of what was contacted, not a judgement about whether it was allowed.

Where it shows up

A monthly inventory of the tags running on your public pages.
A check that nothing new loads before the consent banner is answered.
A dated list of contacted domains for a privacy review.

The request

POST /scrape. diagnostics starts at Pro, and each page costs 2 credits. Each list stops at maxEntries, and the result says when it was truncated, so check that before treating the list as complete.

cURL

curl -X POST https://api.domscout.io/scrape \
  -H "x-api-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://www.example.com/",
    "extractMarkdown": false,
    "diagnostics": {
      "console": false,
      "pageErrors": false,
      "network": true,
      "resources": true,
      "timing": false,
      "maxEntries": 250
    }
  }'

Node.js

const response = await fetch("https://api.domscout.io/scrape", {
  method: "POST",
  headers: { "Content-Type": "application/json", "x-api-key": "YOUR_API_KEY" },
  body: JSON.stringify({
    url: "https://www.example.com/",
    extractMarkdown: false,
    diagnostics: {
      console: false,
      pageErrors: false,
      network: true,
      resources: true,
      timing: false,
      maxEntries: 250
    }
  }),
});
const result = await response.json();
console.log(result.analysis);

Python

import requests

response = requests.post(
    "https://api.domscout.io/scrape",
    headers={"x-api-key": "YOUR_API_KEY"},
    json={
        "url": "https://www.example.com/",
        "extractMarkdown": False,
        "diagnostics": {
            "console": False,
            "pageErrors": False,
            "network": True,
            "resources": True,
            "timing": False,
            "maxEntries": 250
        }
    },
)
print(response.json()["analysis"])

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"net/http"
)

func main() {
	body, _ := json.Marshal(map[string]any{
		"url": "https://www.example.com/",
		"extractMarkdown": false,
		"diagnostics": map[string]any{
			"console": false,
			"pageErrors": false,
			"network": true,
			"resources": true,
			"timing": false,
			"maxEntries": 250,
		},
	})
	req, _ := http.NewRequest("POST", "https://api.domscout.io/scrape", bytes.NewReader(body))
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("x-api-key", "YOUR_API_KEY")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()

	var result map[string]any
	json.NewDecoder(res.Body).Decode(&result)
	fmt.Println(result["analysis"])
}

PHP

<?php
$ch = curl_init('https://api.domscout.io/scrape');
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ['Content-Type: application/json', 'x-api-key: YOUR_API_KEY'],
    CURLOPT_POSTFIELDS => json_encode([
        'url' => 'https://www.example.com/',
        'extractMarkdown' => false,
        'diagnostics' => [
            'console' => false,
            'pageErrors' => false,
            'network' => true,
            'resources' => true,
            'timing' => false,
            'maxEntries' => 250
        ]
    ]),
]);
$response = curl_exec($ch);
if ($response === false) {
    throw new RuntimeException(curl_error($ch));
}
$result = json_decode($response, true);
print_r($result['analysis']);

Ruby

require "json"
require "net/http"

response = Net::HTTP.post(
  URI("https://api.domscout.io/scrape"),
  {
    url: "https://www.example.com/",
    extractMarkdown: false,
    diagnostics: {
      console: false,
      pageErrors: false,
      network: true,
      resources: true,
      timing: false,
      maxEntries: 250
    }
  }.to_json,
  "Content-Type" => "application/json",
  "x-api-key" => "YOUR_API_KEY"
)
puts JSON.parse(response.body)["analysis"]

Java

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Capture {
    public static void main(String[] args) throws Exception {
        String body = """
            {
                "url": "https://www.example.com/",
                "extractMarkdown": false,
                "diagnostics": {
                    "console": false,
                    "pageErrors": false,
                    "network": true,
                    "resources": true,
                    "timing": false,
                    "maxEntries": 250
                }
            }
            """;
        HttpRequest request = HttpRequest.newBuilder(URI.create("https://api.domscout.io/scrape"))
            .header("Content-Type", "application/json")
            .header("x-api-key", "YOUR_API_KEY")
            .POST(HttpRequest.BodyPublishers.ofString(body))
            .build();
        HttpResponse<String> response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}

using System.Net.Http.Json;
using System.Text.Json;

using var client = new HttpClient();
client.DefaultRequestHeaders.Add("x-api-key", "YOUR_API_KEY");

var response = await client.PostAsJsonAsync("https://api.domscout.io/scrape", new {
    url = "https://www.example.com/",
    extractMarkdown = false,
    diagnostics = new {
        console = false,
        pageErrors = false,
        network = true,
        resources = true,
        timing = false,
        maxEntries = 250
    }
});
var result = await response.Content.ReadFromJsonAsync<JsonElement>();
Console.WriteLine(result.GetProperty("analysis"));

Go further

Diagnostics docs

JavaScript error checks

Page weight and load metrics

More in Security, evidence and compliance: Web archiving and evidence · Suspicious link checks · Hacked site detection · Tracking silent edits · Marketing page records · All use cases

Give your product a browser.

Get clean web content and visual proof into your workflow in minutes.

Get your free API key Read the docs