Methodology
Goldie checks a website from outside, the way anyone on the internet can see it. This page says exactly what she looks at, how, how often, and what a result does and doesn't mean, so you can judge it for yourself.
What she sees, not what anyone says
Every result comes from WatchPal looking at the website itself, never from a questionnaire. A result can't be edited, and a problem can't be marked "fine" to make it go away: a job is only ticked off when Goldie looks again and can see the fix.
Two kinds of checking
The daily look (passive checks) runs on every website WatchPal watches, and once on a website nobody has shown is theirs yet (below). It only reads what's already public: DNS and email records, the certificate and the kinds of encrypted connection on offer, the settings the website sends to browsers, cookie flags, the homepage, a published security.txt, certificate-transparency logs and public block lists. Nothing here is more intrusive than loading the website in a browser or looking up its address.
A short crawl, once a week (or sooner when the website changes), only on a website its owner has shown is theirs: a gentle walk through its own pages, as WatchpalBot, following robots.txt. At most 20 pages a host and 40 a website, links two levels deep, one page a second; pages only, never a form sent, never a link that does something (logging out, deleting, adding to a basket), never another website. What it finds (the website's sections, links to its other addresses) tells the other checks where to look.
Deep sniffing (the deep scan, active checks) is off until a website's owner switches it on, and only on a website they've shown is theirs. It connects to the owner's own services to test them: open ports (over IPv4 and IPv6), SSH settings (including whether it accepts password logins, read from the list of login methods the server offers; no password is ever sent), risky HTTP methods, CORS rules, exposed sensitive files, known exposures and known weaknesses (CVEs, including API paths found in the website's own JavaScript), software past its support date, subdomain takeover, mail-server relay settings and open DNS resolvers. It needs the owner's say-so because it sends crafted requests to their servers, not just reads public records. It also reads the scripts the website loads, and (on Business) the full history of the public code of GitHub organisations GitHub has verified for the domain, for secret keys: a person at WatchPal confirms each finding before it counts, and no key is ever stored or tried.
Every check, in full
The same fixed list runs on every website. A check that doesn't apply (no mail servers, say) is left out of the count, never counted as a pass.
The padlock (encryption)
- TLS versions offered (1.2 and 1.3 expected; 1.0 and 1.1 should be off), on the domain and each of its main addresses, and the cipher suites accepted: a broken one fails, one without forward secrecy warns
- The certificate: valid, in date, for the right name; when it isn't trusted, each problem found is named
- Plain HTTP redirecting to HTTPS, and HSTS
- Mixed content: a form that submits over plain HTTP fails; scripts or styles loaded over HTTP warn; images and media are listed
- SPF, DKIM and DMARC, including whether DMARC actually blocks fake mail (
p=quarantineorp=reject) - Mail encryption: STARTTLS on each mail server, MTA-STS and DANE (TLSA records)
What browsers are told
- Content-Security-Policy, judged on its script rules: a policy that still allows inline or any-origin scripts doesn't count
- Clickjacking settings (
frame-ancestorsorX-Frame-Options) andX-Content-Type-Options: nosniff - Cookie flags (Secure, HttpOnly, SameSite)
- Scripts loaded from other websites, and whether they're pinned with Subresource Integrity
- JavaScript libraries the homepage loads (jQuery, Bootstrap and others) with known holes, from the Retire.js database
- WordPress plugins and themes with known holes, from the versions the homepage's own addresses show, looked up in Wordfence Intelligence
- Server software and version numbers given away in headers
The domain name and DNS
- Registration: when it runs out, and whether it's locked against transfer
- DNSSEC, the CAA record, and certificates issued for the domain (from certificate-transparency logs) checked against it
- Zone transfers refused by every nameserver
- The website's other addresses: found in certificate-transparency logs, DNS, links on the homepage and, on a plan, public subdomain databases (a name from a database counts only once it resolves)
- Records pointing at services that no longer exist, and storage buckets anyone can read
Block lists, privacy and contact
- Google's malware and phishing lists (Web Risk) and Spamhaus's spam lists
- Whether security DNS filters (Quad9, Cloudflare's security resolver, CleanBrowsing) block the domain
- A privacy policy, a cookie banner when the homepage loads advertising or visitor-recording tags, a notice and
a way to say no when it only counts visits, and a
security.txt - Whether the website answers: the domain and each key host (an address that has answered on the web), every 5 minutes; a key host that stops answering makes it not passing
Deep sniffing
- Open ports, over IPv4 and IPv6, and SSH settings (password logins read from the methods the server offers; no password is ever sent)
- Admin login pages, sensitive files and debug pages, risky HTTP methods and CORS rules
- Exposed services and panels, and known weaknesses (CVEs), including API paths found in the website's own JavaScript and the weekly crawl (below). To confirm a known weakness exists, a few tests go one step and stop there: they may leave a test file (the result says where), run a harmless command, or make the server contact an outside callback service. The result shows what came back
- Software support status: software and operating-system releases past their support date, and WordPress and other CMS versions read from the website's own generator tag (WordPress checked against WordPress.org's list of releases with known holes)
- Subdomain takeover, mail-server relay settings and open DNS resolvers
- Secret keys in the scripts the website loads, and (on Business) in the full history of the public code of GitHub organisations GitHub has verified for the domain. A key in the current code fails; one only in the history warns. Test keys, placeholders and keys that are public by design aren't counted, a person at WatchPal confirms each finding before it counts, and no key is ever stored in full or tried
Before it's shown to be yours: one look
A website can be checked once before anyone shows it's theirs, so you see a real result before changing anything. Because nobody has shown it's theirs yet, anyone can ask for it on any domain, so it's limited to what anyone could see anyway: the passive checks, on the domain itself (not its other addresses; certificate logs give a count of other names, which aren't kept), run once, never re-checked, never monitored and never public (no badge, no page). It's deleted after 7 days unless ownership is proven; then the website is checked like any other, from that point on. A website another account has shown is theirs can't be checked this way.
The same look runs from the home page without an account: once per domain per day, whoever asks (a second visitor that day sees the same result, with its time). Signing up keeps it. Watching every day, the badge and deep sniffing come with a plan. When a plan ends, watching and the badge pause, deep sniffing switches off, and the results are kept.
Showing it's yours, and saying yes to deep sniffing
Showing WatchPal a website is yours lets you switch on deep sniffing for it; it's never treated as the say-so itself. Before you switch it on, the Deep sniffing switch on your website's Watching page (under Addresses) says which addresses it would test; switching it on confirms that list. Each address is confirmed as it reaches the internet at that moment: a server address address by address, an alias to a provider (a load balancer, say) by its name, and an address behind a CDN or proxy by its name, because the server addresses behind those change. You can switch it off any time, and the deep results stop being collected.
After that, a key host that points somewhere new, or a new key host, waits for your "Yes, it's ours" before deep sniffing includes it; until then it gets the daily look as usual. Secondary addresses (the website's other names that aren't key hosts) only ever get the daily look. If WatchPal ever lists an address that isn't yours, leave it unconfirmed, or write to us to report it as not yours: a person at WatchPal reviews it, and if the review agrees, it's removed for good. You can never remove an address yourself, so nothing failing can be hidden by leaving it out.
When deep sniffing runs
The daily look and the daily re-check that the website is still yours run once a day at a fixed time, 03:17 UTC. Deep sniffing runs every night right after the daily passive check. Every night it first looks for changes on the addresses it covers, using what the daily checks already read (addresses, server software, the scripts the homepage loads, the structure of the page (its forms and generator tag, not its words), the certificate's issuer and names, mail and name servers, new names) and the sections the weekly crawl found, and runs its checks in full only when something changed, the last run didn't finish, or we updated its tests; and at least every 30 days whatever happens. An open deep finding is re-checked every night on its own, so a fix is seen the next day: only that check, and for a known weakness only the tests that found it. Secrets in public code are read every night (only new commits).
Keeping results current
A website on a plan is monitored continuously, not only checked once a day. Between the daily checks, watchers take a quick reading and compare it with the last one, and only what changed is checked again:
- Every 5 minutes, the website: one request to the domain and to each key host, the same request the daily check makes. It shows whether each answers and, from the page that came back, whether what the checks judge there changed: the settings sent to browsers, the scripts the page loads, and its structure (forms and generator tag, not its words). A change re-runs those checks at once.
- Every 15 minutes, DNS: the records the checks read (SPF, DMARC, MTA-STS, mail servers, nameservers, CAA, DNSSEC, and each key host's address). A changed record re-runs the checks it feeds.
- Once a day, every passive check, the certificates (their dates are known ahead, so one running out is flagged 14 days before), DKIM and the block lists included.
- Deep sniffing whenever something it depends on changed (the readings above included), and at least every 30 days.
A change is looked at a second time before it counts, so a blip doesn't flip a result, and a reading that couldn't be taken changes nothing. If a website goes down, that's recorded honestly instead of leaving an old pass standing as if it were today's. A deep check that wasn't re-tested on a day, because nothing it depends on had changed, counts that day as No changes, never as a test that day. Each result says when it was last checked.
What a result means
A pass means our specific method, from outside, didn't find a problem when it ran: it isn't a guarantee. Something to fix is a job, a door to close, never "you've been hacked" unless the result says so plainly (a block list that names the website, say). Couldn't check means we couldn't see it this time (the website was down, or a firewall answered instead of it), and it's left out of the count rather than guessed either way. Counts are honest ("I could judge 24 things from outside, 13 passed"), there's no score, and nothing here is a certificate or an audit.
The badge and its page
An owner can switch on a "Watched by Goldie" badge for their website, linking to its public profile: under watch since, continuously monitored, when Goldie last looked, and the website's quiet days, records, XP and achievements. Never what she found: no results, no counts of what passed, no score.
All of it comes from what Goldie saw herself. A quiet day is a day she checked the website and, at the end of it, nothing on its to-do was open, nice extras included; a day she didn't check ends the streak too. XP is 10 for every quiet day, and for every job she has seen fixed in her own re-check 25 (This week), 50 (Soon) or 75 (a nice extra); something new opening loses 75, 50 or 25, a job opening again after it was fixed twice that. XP never goes below 0. An achievement is kept once earned and shows the date it was earned. None of it is a promise that nothing's wrong.
The badge only says "Watched by Goldie" while the website is still shown to be the owner's, on a plan that watches it, and really checked in the last 72 hours; otherwise the badge and its page say it isn't being watched right now.
Firewalls and where she looks from
Some websites sit behind a firewall (Cloudflare, Vercel, AWS WAF) that can answer an automated visit with a challenge page instead of the real website. When that happens, Goldie says she couldn't check those things, rather than judging the challenge page, because that page says nothing about the website. By default she sees what the public internet sees, firewall included. An owner can let WatchpalBot through (see Help): that changes where she looks from, not how she judges what she sees.
Goldie's words
What Goldie says about each check is written in advance and checked by us, so the same result always gets the same explanation. Answers to questions people type are written by AI from the website's own results, and the chat says so, under its box.
What we don't do
We don't try to log in, guess passwords, read or take data beyond what a test needs to show it worked, or run tests that flood a website with traffic. The daily look only reads what's public. Deep sniffing checks settings, what's exposed and known weaknesses: for some, that means sending the weakness's published test request and looking for its harmless echo, and it stops at whether the weakness applies. Its mail-relay test stops before any message is ever sent, and its database checks only see whether a service answers without a login, never what's stored. A few tests go one step to confirm a weakness: one may leave a test file (the result says where), run a harmless command, or make the server contact an outside callback service, and it stops there. Going further, to see what an attacker could do with it, isn't part of deep sniffing.
Questions about how WatchPal checks: [email protected]. See also Help, WatchpalBot, Terms and Privacy.