For teams moving a site

Check every old URL against the new site before search engines do

Capture each old URL and its new counterpart together, and compare where it lands, what it says and what it declares.

Get your free API key Try the playground

The problem

A replatform goes live on a Monday. By Thursday the old blog's traffic has vanished because its redirects point at the home page, product pages have lost their canonical tags, and a section nobody remembered never moved at all. The spreadsheet of URL mappings existed; nobody had a quick way to check it.

How domscout handles it

Start with POST /map on the old site for the list of URLs. Then send each old URL and its new counterpart in one batch. For each, markdownMeta.finalUrl shows where the URL ended up after redirects, metadata.httpStatus what it answered, and the title, word count and Markdown let you compare what the two pages say; an extract field reads the canonical tag on both. Run it against staging before launch and against production after, and the problems arrive as a list of rows rather than a slow decline in search traffic.

Where it shows up

A pre-launch check of every mapping in the redirect plan.
A post-launch sweep for redirects that land on the home page.
A content comparison for pages rewritten in the move.

The request

POST /batch. Batch starts at Business and /map at Pro. Each item here costs 2 credits, and /map 2 a request. A batch takes up to 100 requests, so a large site goes through in several.

cURL

curl -X POST https://api.domscout.io/batch \
  -H "x-api-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "requests": [
      {
        "url": "https://old.example.com/pricing",
        "extractMarkdown": true,
        "extract": {
          "fields": {
            "canonical": {
              "selector": "link[rel='\''canonical'\'']",
              "type": "attribute",
              "attribute": "href"
            }
          }
        }
      },
      {
        "url": "https://www.example.com/pricing",
        "extractMarkdown": true,
        "extract": {
          "fields": {
            "canonical": {
              "selector": "link[rel='\''canonical'\'']",
              "type": "attribute",
              "attribute": "href"
            }
          }
        }
      }
    ]
  }'

Node.js

const response = await fetch("https://api.domscout.io/batch", {
  method: "POST",
  headers: { "Content-Type": "application/json", "x-api-key": "YOUR_API_KEY" },
  body: JSON.stringify({
    requests: [
      {
        url: "https://old.example.com/pricing",
        extractMarkdown: true,
        extract: {
          fields: {
            canonical: {
              selector: "link[rel='canonical']",
              type: "attribute",
              attribute: "href"
            }
          }
        }
      },
      {
        url: "https://www.example.com/pricing",
        extractMarkdown: true,
        extract: {
          fields: {
            canonical: {
              selector: "link[rel='canonical']",
              type: "attribute",
              attribute: "href"
            }
          }
        }
      }
    ]
  }),
});
console.log(await response.json());

Python

import requests

response = requests.post(
    "https://api.domscout.io/batch",
    headers={"x-api-key": "YOUR_API_KEY"},
    json={
        "requests": [
            {
                "url": "https://old.example.com/pricing",
                "extractMarkdown": True,
                "extract": {
                    "fields": {
                        "canonical": {
                            "selector": "link[rel='canonical']",
                            "type": "attribute",
                            "attribute": "href"
                        }
                    }
                }
            },
            {
                "url": "https://www.example.com/pricing",
                "extractMarkdown": True,
                "extract": {
                    "fields": {
                        "canonical": {
                            "selector": "link[rel='canonical']",
                            "type": "attribute",
                            "attribute": "href"
                        }
                    }
                }
            }
        ]
    },
)
print(response.json())

package main

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

func main() {
	body, _ := json.Marshal(map[string]any{
		"requests": []any{
			map[string]any{
				"url": "https://old.example.com/pricing",
				"extractMarkdown": true,
				"extract": map[string]any{
					"fields": map[string]any{
						"canonical": map[string]any{
							"selector": "link[rel='canonical']",
							"type": "attribute",
							"attribute": "href",
						},
					},
				},
			},
			map[string]any{
				"url": "https://www.example.com/pricing",
				"extractMarkdown": true,
				"extract": map[string]any{
					"fields": map[string]any{
						"canonical": map[string]any{
							"selector": "link[rel='canonical']",
							"type": "attribute",
							"attribute": "href",
						},
					},
				},
			},
		},
	})
	req, _ := http.NewRequest("POST", "https://api.domscout.io/batch", 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()

	raw, _ := io.ReadAll(res.Body)
	fmt.Println(string(raw))
}

PHP

<?php
$ch = curl_init('https://api.domscout.io/batch');
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([
        'requests' => [
            [
                'url' => 'https://old.example.com/pricing',
                'extractMarkdown' => true,
                'extract' => [
                    'fields' => [
                        'canonical' => [
                            'selector' => 'link[rel=\'canonical\']',
                            'type' => 'attribute',
                            'attribute' => 'href'
                        ]
                    ]
                ]
            ],
            [
                'url' => 'https://www.example.com/pricing',
                'extractMarkdown' => true,
                'extract' => [
                    'fields' => [
                        'canonical' => [
                            'selector' => 'link[rel=\'canonical\']',
                            'type' => 'attribute',
                            'attribute' => 'href'
                        ]
                    ]
                ]
            ]
        ]
    ]),
]);
$response = curl_exec($ch);
if ($response === false) {
    throw new RuntimeException(curl_error($ch));
}
echo $response;

Ruby

require "json"
require "net/http"

response = Net::HTTP.post(
  URI("https://api.domscout.io/batch"),
  {
    requests: [
      {
        url: "https://old.example.com/pricing",
        extractMarkdown: true,
        extract: {
          fields: {
            canonical: {
              selector: "link[rel='canonical']",
              type: "attribute",
              attribute: "href"
            }
          }
        }
      },
      {
        url: "https://www.example.com/pricing",
        extractMarkdown: true,
        extract: {
          fields: {
            canonical: {
              selector: "link[rel='canonical']",
              type: "attribute",
              attribute: "href"
            }
          }
        }
      }
    ]
  }.to_json,
  "Content-Type" => "application/json",
  "x-api-key" => "YOUR_API_KEY"
)
puts response.body

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 = """
            {
                "requests": [
                    {
                        "url": "https://old.example.com/pricing",
                        "extractMarkdown": true,
                        "extract": {
                            "fields": {
                                "canonical": {
                                    "selector": "link[rel='canonical']",
                                    "type": "attribute",
                                    "attribute": "href"
                                }
                            }
                        }
                    },
                    {
                        "url": "https://www.example.com/pricing",
                        "extractMarkdown": true,
                        "extract": {
                            "fields": {
                                "canonical": {
                                    "selector": "link[rel='canonical']",
                                    "type": "attribute",
                                    "attribute": "href"
                                }
                            }
                        }
                    }
                ]
            }
            """;
        HttpRequest request = HttpRequest.newBuilder(URI.create("https://api.domscout.io/batch"))
            .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 var client = new HttpClient();
client.DefaultRequestHeaders.Add("x-api-key", "YOUR_API_KEY");

var response = await client.PostAsJsonAsync("https://api.domscout.io/batch", new {
    requests = new[] {
        new {
            url = "https://old.example.com/pricing",
            extractMarkdown = true,
            extract = new {
                fields = new {
                    canonical = new {
                        selector = "link[rel='canonical']",
                        type = "attribute",
                        attribute = "href"
                    }
                }
            }
        },
        new {
            url = "https://www.example.com/pricing",
            extractMarkdown = true,
            extract = new {
                fields = new {
                    canonical = new {
                        selector = "link[rel='canonical']",
                        type = "attribute",
                        attribute = "href"
                    }
                }
            }
        }
    }
});
Console.WriteLine(await response.Content.ReadAsStringAsync());

Go further

Find every page on a site

SEO regression checks

Batch docs

More in SEO and site health: SEO regression checks · Link preview checks · Find every page on a site · JavaScript SEO checks · Page weight and load metrics · Backlink checks · JSON-LD structured data checks · hreflang checks · Website audits for prospects · 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