# Compare domains

The compare view runs the same checks on 2 to 4 domains and puts the results side by side. Use it to see
how your domain stacks up against a competitor, to check that a new domain is set up like the old one, or
to find the one domain in a group that is different from the rest.

## Running a comparison

Open [Compare](/compare) while signed in, enter 2 to 4 domains and choose up to 4 checks: for example the
SSL checker, the email checker, the security headers check and a DNS lookup. The line under the form shows
what the comparison will cost before you run it. Results arrive one check at a time, so the first columns
fill in while the slower checks are still running.

On a domain report you can choose **Compare** beside **Run report**: the compare page opens with that
domain already filled in. Domains are never put in the page address, so they don't end up in your browser
history, in shared links or in our logs.

## Reading the grid

Each check gets its own block, with one column per domain:

- **Score**: the check's score out of 100 for each domain, for checks that grade. The highest one is
  marked as the best. Checks that don't grade say whether they got an answer.
- **Findings**: every finding raised for any of the domains, on one line each, with what each domain
  got: fail, warning, info, pass, or not raised. Findings that differ between the domains come first and
  carry a **Differs** label.
- **Details**: open a domain's cell to see that check's full result for it, exactly as the check's own
  page shows it.

On a phone the grid becomes one card per domain, listing its score and the findings that differ.

## What it costs

Each check on each domain costs that check's own price, and cached answers cost the same. The SSL
checker at 1 credit plus the email checker at 2 credits on 3 domains is
9 credits. A check that gets no
answer from its sources costs nothing and shows why in its cell; if no check gets an answer, nothing is
charged at all. Your balance must cover the whole comparison before it starts.

Compare needs a free account: the free checks without an account don't cover it. You can run 30
comparisons an hour.

## By API

Send `POST /v1/compare` with `domains` (2 to 4) and `tools` (1 to 4 check ids). The answer has a `cells`
list with every check's result per domain (or an `error` for a cell that got no answer), the lined-up
findings in `rows` with `differs` set where the domains disagree, each graded check's `scores`, a one-line
`summary` and the credits used. Add `?stream=true` to get a stream address instead: each cell arrives as
a `cell` section as soon as it is in, and the last event is the full comparison. A retry with the same
`X-Request-Id` returns the stored comparison for 24 hours without charging again.

curl

```sh
curl -X POST "https://api.dnssuper.com/v1/compare" \
  -H "Authorization: Bearer $DNSSUPER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"domains": ["example.com", "example.net"], "tools": ["ssl-checker", "email-checker"]}'
```

Python

```python
import os

import httpx

response = httpx.post(
    "https://api.dnssuper.com/v1/compare",
    headers={"Authorization": f"Bearer {os.environ['DNSSUPER_API_KEY']}"},
    json={"domains": ["example.com", "example.net"], "tools": ["ssl-checker", "email-checker"]},
    timeout=120,
)
comparison = response.json()
print(comparison["summary"])
for row in comparison["rows"]:
    if row["differs"]:
        print(row["title"], row["per_domain"])
```

TypeScript

```ts
const response = await fetch("https://api.dnssuper.com/v1/compare", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.DNSSUPER_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({ domains: ["example.com", "example.net"], tools: ["ssl-checker", "email-checker"] }),
});
const comparison = await response.json();
console.log(comparison.summary);
```

Tool compare_domains on https://mcp.dnssuper.com/mcp

```text
compare_domains(
  domains=["example.com", "example.net"],
  tools=["ssl-checker", "email-checker"],
  detail="compact",
)
```

Checks you can compare: the DNS lookup, WHOIS, the DNSSEC checker, the domain report, the email checker,
the MTA-STS checker, security headers, security.txt, AI crawler access, the tech stack checker, the
redirect checker and the SSL checker. Website checks look at each domain's home page over HTTPS.

## Questions

### Can I share a comparison?

Not yet. You can export it as JSON, CSV or PDF from the menu under the results.

### Why is a cell empty or marked "No answer"?

That check got no answer for that domain: the site or its servers didn't respond, or the check was run on
that site many times in a short while by everyone together. That cell costs nothing. Run the comparison
again in a minute.

### Why does a domain have no score?

Only checks that grade have scores (the email checker, the SSL checker, the security headers check and
the domain report). For the others, the findings show the differences.

### Do comparisons skip the cache?

No: a check answered in the last few minutes is reused, and costs the same. The
cache keeps comparisons quick and keeps the load on the checked sites low. The API's `fresh: true` asks
every check again.
