For teams that deploy front ends

Find the console errors and broken assets a deploy shipped

Load the page in a real browser and get back its console errors, uncaught exceptions and failed requests as JSON.

Get your free API key Try the playground

The problem

The page returns 200 and the HTML looks right, but a script threw on load, an image path changed and a font now answers 404. A server-side check cannot see any of it, because none of it happens until a browser runs the page.

How domscout handles it

diagnostics records what the browser saw while the page loaded: console messages, uncaught page errors, requests that failed outright, and every response with its status, so an asset that answered 404 or 500 is listed even though the page itself loaded. A summary counts each kind, so a CI step can fail when pageErrorCount or failedRequestCount is above zero without reading the lists. Cookies, authorization headers, form values and request bodies are never returned.

Where it shows up

A post-deploy smoke test on the pages that carry revenue.
A pre-merge check against the preview deployment.
A scheduled sweep that turns new console errors into tickets.

The request

POST /scrape. diagnostics starts at Pro and adds 1 credit, so each page costs 2. The findings are under analysis.diagnostics. With maxEntries at 250 or less they come back in the same response; without it the capture runs as a job to poll. debugOverlay, on every plan, draws the same findings onto a screenshot instead.

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/checkout",
    "extractMarkdown": false,
    "diagnostics": {
      "console": true,
      "pageErrors": true,
      "network": true,
      "resources": false,
      "timing": false,
      "maxEntries": 100
    }
  }'

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/checkout",
    extractMarkdown: false,
    diagnostics: {
      console: true,
      pageErrors: true,
      network: true,
      resources: false,
      timing: false,
      maxEntries: 100
    }
  }),
});
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/checkout",
        "extractMarkdown": False,
        "diagnostics": {
            "console": True,
            "pageErrors": True,
            "network": True,
            "resources": False,
            "timing": False,
            "maxEntries": 100
        }
    },
)
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/checkout",
		"extractMarkdown": false,
		"diagnostics": map[string]any{
			"console": true,
			"pageErrors": true,
			"network": true,
			"resources": false,
			"timing": false,
			"maxEntries": 100,
		},
	})
	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/checkout',
        'extractMarkdown' => false,
        'diagnostics' => [
            'console' => true,
            'pageErrors' => true,
            'network' => true,
            'resources' => false,
            'timing' => false,
            'maxEntries' => 100
        ]
    ]),
]);
$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/checkout",
    extractMarkdown: false,
    diagnostics: {
      console: true,
      pageErrors: true,
      network: true,
      resources: false,
      timing: false,
      maxEntries: 100
    }
  }.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/checkout",
                "extractMarkdown": false,
                "diagnostics": {
                    "console": true,
                    "pageErrors": true,
                    "network": true,
                    "resources": false,
                    "timing": false,
                    "maxEntries": 100
                }
            }
            """;
        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/checkout",
    extractMarkdown = false,
    diagnostics = new {
        console = true,
        pageErrors = true,
        network = true,
        resources = false,
        timing = false,
        maxEntries = 100
    }
});
var result = await response.Content.ReadFromJsonAsync<JsonElement>();
Console.WriteLine(result.GetProperty("analysis"));

Go further

Diagnostics docs

Screenshots for support tickets

Page weight and load metrics

More in Testing and QA: Responsive layout checks · Visual regression testing · Signup and checkout flow checks · Hover, focus and dark mode screenshots · Localization screenshots · Unlabelled control checks · A screenshot of every step · Embedded widget checks · Screenshots for support tickets · Ad landing page checks · Before and after hydration · Selectors for test automation · Print layout checks · 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