Phishing Site Takedown: Find Who Can Actually Remove It
A phishing site takedown is a routing problem. Three kinds of parties can kill a page impersonating your brand: the network serving it, the registrar that sold the domain, and the browser blocklists that can warn people
A phishing site takedown is a routing problem. Three kinds of parties can kill a page impersonating your brand: the network serving it, the registrar that sold the domain, and the browser blocklists that can warn people away from it. Most reports stall because they reach the wrong party, or the right party through the wrong channel.
The second failure is more common than it sounds. In the May to July 2026 hosting-network data from Interisle's Cybercrime Information Center, 380,272 reported phishing attacks sat on Cloudflare's AS13335. That is about 26% of the 1,450,117 attacks reported that quarter. Look up the IP behind one of those sites, email the abuse address in its registry record, and you get an automated reply pointing you to a web form.
When you need to take down a phishing website, the lookups are the slow part. This post builds a Python script that takes a phishing URL and returns everything a takedown needs: captured evidence, every IP the domain resolves to, the network and abuse desk behind each IP, the registrar's abuse contact from RDAP, and a draft report per desk. It runs in a few seconds per URL.
TL;DR
- Report to the network, the registrar, and the blocklists in parallel. Each removes or blocks a different layer.
- Capture evidence first: UTC timestamp, full URL, redirect chain, response headers, a SHA-256 of the page, and screenshots of the fake and real pages with address bars visible.
- Resolve every A and AAAA address returned by your resolver, and repeat from another resolver or region when GeoDNS, fast-flux or rotating infrastructure is suspected. One domain can map to several IPs and occasionally to more than one provider.
- If the IP belongs to a CDN, the registered abuse email is often the wrong channel. Cloudflare wants its web form and forwards reports to the origin host.
- Get the registrar from RDAP, not WHOIS. ICANN made RDAP the definitive source for gTLD registration data in January 2025.
- Re-check at 24 and 72 hours. Takedowns that "worked" often come back on a new path. The short version of a phishing website takedown: find every party that can act, send each one a short report with evidence it can verify, use the channel it actually reads, and verify the result yourself. The script below automates the lookups and the drafting, so the slow part left is the human judgment of what to send.
Who handles a phishing site takedown
Before any code, here is the routing table the script implements. Every row is a separate report, and none of them waits on the others.
| Party | What they can do | What they need from you | Where to send it |
|---|---|---|---|
| Hosting provider | Remove the content or suspend the account | Full URL, UTC timestamp, screenshot, what it impersonates | Abuse contact registered for the IP's network |
| CDN or reverse proxy | Forward to the origin host; remove only content it hosts itself | Same as the host | Often a web form, not email |
| Registrar | Suspend the domain, which kills every URL on it | Screenshot showing what the phish targets, plus the complete URL | Registrar abuse contact from RDAP |
| Registry | Put the domain on server hold | Escalation when the registrar stalls | Registry abuse desk for the TLD |
| Browser blocklists | Warn users within the browser; content stays up | The URL | Google Safe Browsing, Microsoft, Netcraft, APWG |
Which report lands first depends on what kind of site it is. In the same quarter, 914,576 of 1,129,248 unique phishing domains (81%) were registered by the attacker for the purpose. For those, a registrar suspension takes out the whole domain, including the paths you haven't found yet.
A compromised legitimate site is different. ICANN's own compliance advisory on the 2024 DNS abuse amendments walks through a phishing page on a franchisee's subdomain of a three-year-old dealership domain. The registrar weighs the collateral damage, decides suspension isn't appropriate, and notifies the domain owner instead. When the domain owner is a victim too, the host is your lever.
The registrars' own abuse reporting guide goes further and asks reporters to contact the host first, treating the registrar as a follow-up. For a compromised site, that's right. For a lookalike domain registered last week to copy your login page, there's no collateral to damage, and I'd send both reports on day one.
Step 1: Capture evidence before you touch anything
Phishing kits get moved, cloaked, and redeployed, sometimes within hours. Capture the page once, timestamp it in UTC, preserve a bounded copy of the bytes that were served, and hash that saved artifact. The hash lets you verify or compare the retained capture later; it is not useful as standalone proof if the underlying bytes are discarded.
import hashlib
import ipaddress
import json
import os
import socket
import sys
from datetime import datetime, timezone
from pathlib import Path
from urllib.parse import urljoin, urlsplit
import requests
import tldextract
API_KEY = os.environ.get("IPGEO_API_KEY")
TIMEOUT = (3.05, 10) # (connect, read) seconds
MAX_BODY_BYTES = 5 * 1024 * 1024
MAX_REDIRECTS = 8
REDIRECT_CODES = {301, 302, 303, 307, 308}
EVIDENCE_DIR = Path("evidence")
EVIDENCE_DIR.mkdir(exist_ok=True)
BROWSER_UA = (
"Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
"AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0 Safari/537.36"
)
def _validate_public_http_url(url: str) -> None:
"""Reject malformed URLs and destinations that resolve to non-public space."""
parts = urlsplit(url)
if parts.scheme not in {"http", "https"} or not parts.hostname:
raise ValueError("only absolute http/https URLs are supported")
if parts.username or parts.password:
raise ValueError("credentials in URLs are not supported")
port = parts.port or (443 if parts.scheme == "https" else 80)
infos = socket.getaddrinfo(
parts.hostname,
port,
family=socket.AF_UNSPEC,
type=socket.SOCK_STREAM,
)
for info in infos:
addr = ipaddress.ip_address(info[4][0])
if isinstance(addr, ipaddress.IPv6Address) and addr.ipv4_mapped:
addr = addr.ipv4_mapped
if not addr.is_global:
raise ValueError(f"refusing non-public destination {addr}")
def capture_evidence(url: str) -> dict:
"""Capture a bounded copy of the final response and its redirect chain."""
record = {
"reported_url": url,
"captured_at_utc": datetime.now(timezone.utc).isoformat(timespec="seconds"),
}
current = url
chain = []
try:
for _ in range(MAX_REDIRECTS + 1):
_validate_public_http_url(current)
with requests.get(
current,
timeout=TIMEOUT,
headers={"User-Agent": BROWSER_UA},
allow_redirects=False,
stream=True,
) as resp:
chain.append(resp.url)
location = resp.headers.get("Location")
if resp.status_code in REDIRECT_CODES and location:
current = urljoin(resp.url, location)
continue
body = bytearray()
for chunk in resp.iter_content(64 * 1024):
if not chunk:
continue
body.extend(chunk)
if len(body) > MAX_BODY_BYTES:
raise ValueError("response body exceeded 5 MiB")
digest = hashlib.sha256(body).hexdigest()
artifact = EVIDENCE_DIR / f"{digest}.bin"
artifact.write_bytes(body)
keep = (
"server",
"via",
"cf-ray",
"x-served-by",
"content-type",
"date",
)
record.update({
"status": resp.status_code,
"redirect_chain": chain,
"headers": {
k: v
for k, v in resp.headers.items()
if k.lower() in keep
},
"body_sha256": digest,
"body_file": str(artifact),
})
return record
raise ValueError(f"more than {MAX_REDIRECTS} redirects")
except (
requests.RequestException,
socket.gaierror,
OSError,
ValueError,
) as exc:
record["fetch_error"] = f"{type(exc).__name__}: {exc}"
return record
The headers are there for a reason. A Server: cloudflare and a CF-RAY value in your evidence tell the recipient, and you, that the IP is an edge node and not the origin.
The script doesn't take screenshots, and registrars ask for them. The guide ICANN's advisory points to wants screenshots of both the phishing page and the real page it imitates, with the URL bar visible, plus the full URLs and, if you have it, the phishing email with complete headers. Take the screenshots in a real browser. Playwright works if you want them in the pipeline.
Pitfall: This script intentionally fetches attacker-controlled URLs. Run it only inside a disposable VM or container with no cloud instance role, no route to your internal network, and outbound rules blocking private, loopback, link-local, metadata and other non-public address space. The URL checks above are defense in depth, not a replacement for that network boundary. Never type credentials into the phishing form, and expect cloaking.
Step 2: Resolve every IP, not just the first one
ping gives you one address. A phishing domain can have several, and the one you happen to get depends on your resolver.
def resolve_all(hostname: str) -> list[str]:
"""A/AAAA addresses returned by this resolver for this query."""
try:
infos = socket.getaddrinfo(
hostname,
443,
family=socket.AF_UNSPEC,
type=socket.SOCK_STREAM,
)
except socket.gaierror as exc:
# NXDOMAIN or SERVFAIL: already suspended, or DNS is flapping. Recheck before reporting.
print(f"DNS lookup failed for {hostname}: {exc}", file=sys.stderr)
return []
return sorted({info[4][0] for info in infos})
I'll use example.com as the stand-in target throughout, because it is safe to query and, at the time of writing, it happens to sit behind Cloudflare, which is exactly the case that trips people up. It resolves to four addresses: two IPv4 and two IPv6. Two lookups a few minutes apart returned 104.20.23.154 and then 172.66.147.243. Same domain, same network, different answer.
Most of the addresses returned in one query land on the same provider. When they don't, you owe each provider its own report. Treat this as a snapshot from one resolver and one vantage, not a global inventory of every address the domain may return.
Step 3: Find the network and its abuse desk
You can get the abuse contact for an IP from RDAP directly, but the five regional registries shape their records differently, and you end up walking nested entity roles per registry. RIPEstat, ipinfo, IPLocate and IPGeolocation all expose abuse contacts if you'd rather not. I'm using IPGeolocation's abuse contact data for the examples because one call returns the ASN, a CDN flag, and the registered abuse contact together, which is the exact trio this step needs.
The trade-off: lookup by domain, the abuse module, and the dedicated ASN endpoint used later are paid-plan features (there's a trial). If you handle a few takedowns a year, RIPEstat in a browser tab is fine. If takedowns are a queue, the API call is cheaper than your time.
Here is the domain lookup with abuse data. I'm excluding the time zone, currency, and country metadata objects the endpoint also returns, because none of them help route a report.
curl -s "https://api.ipgeolocation.io/v3/ipgeo?apiKey=$IPGEO_API_KEY&ip=example.com&include=abuse&excludes=time_zone,currency,country_metadata,location.country_emoji,location.country_flag"
{
"domain": "example.com",
"ip": "172.66.147.243",
"location": {
"continent_code": "NA",
"continent_name": "North America",
"country_code2": "US",
"country_code3": "USA",
"country_name": "United States",
"country_name_official": "United States of America",
"country_capital": "Washington, D.C.",
"state_prov": "California",
"state_code": "US-CA",
"district": "China Basin",
"city": "San Francisco",
"zipcode": "94107-1907",
"latitude": "37.78035",
"longitude": "-122.39059",
"is_eu": false,
"geoname_id": "7288594"
},
"network": {
"connection_type": "",
"route": "172.66.144.0/20",
"is_anycast": false,
"is_cdn": true,
"cdn_provider_name": "Cloudflare"
},
"asn": {
"as_number": "AS13335",
"organization": "Cloudflare, Inc.",
"country": "US",
"type": "HOSTING",
"domain": "cloudflare.com",
"date_allocated": "2010-07-14",
"rir": "ARIN"
},
"company": {
"name": "Cloudflare, Inc.",
"type": "HOSTING",
"domain": "cloudflare.com"
},
"abuse": {
"route": "172.64.0.0/13",
"country": "US",
"name": "Abuse",
"organization": "Cloudflare, Inc.",
"kind": "group",
"address": "101 Townsend Street, San Francisco, CA, 94107, United States",
"emails": ["[email protected]"],
"phone_numbers": ["+16503198930"]
}
}
Three fields do the routing. network.is_cdn with cdn_provider_name tells you this is an edge, not an origin. abuse.emails is an array, not a string, so index it. And abuse.route is the block the abuse desk answers for, here a /13 that is far wider than the /20 the IP is routed in, which tells you the contact belongs to the network operator rather than to whoever runs the site.
The domain lookup resolves one IP per call, so the script calls the endpoint once per IP from Step 2 instead.
IPGEO_URL = "https://api.ipgeolocation.io/v3/ipgeo"
def network_for(ip: str) -> dict | None:
"""Who announces this IP, whether it's a CDN edge, and its registered abuse desk."""
if not API_KEY:
raise RuntimeError("Set IPGEO_API_KEY in the environment")
params = {"apiKey": API_KEY, "ip": ip, "include": "abuse"}
try:
resp = requests.get(IPGEO_URL, params=params, timeout=TIMEOUT)
except requests.RequestException as exc:
# Do not print the exception object: it may contain the URL and API key.
print(
f"Lookup failed for {ip}: {type(exc).__name__}",
file=sys.stderr,
)
return None
if resp.status_code != 200:
# 401: the key's plan doesn't cover this data. 423: bogon. 429: out of credits.
print(f"Lookup for {ip} returned HTTP {resp.status_code}: {resp.text[:200]}", file=sys.stderr)
return None
try:
data = resp.json()
except ValueError:
print(f"Lookup for {ip} returned invalid JSON", file=sys.stderr)
return None
network = data.get("network") or {}
asn = data.get("asn") or {}
abuse = data.get("abuse") or {}
return {
"ip": data.get("ip", ip),
"asn": asn.get("as_number"),
"asn_org": asn.get("organization"),
"asn_type": asn.get("type"),
"is_cdn": bool(network.get("is_cdn")),
"cdn_provider": network.get("cdn_provider_name") or None,
"abuse_org": abuse.get("organization"),
"abuse_emails": abuse.get("emails") or [],
"abuse_phones": abuse.get("phone_numbers") or [],
"abuse_route": abuse.get("route"),
# This is the registered abuse contact's country, not proof of
# where the origin server or website operator is located.
"abuse_country": abuse.get("country"),
}
abuse_country is only a routing hint: it identifies the country attached to the registered abuse contact. It does not establish the origin server's location or legal jurisdiction, especially when the visible IP belongs to a CDN. Verify the relevant national CERT manually before escalating.
The CDN case: right organization, wrong channel
The abuse record above is accurate. [email protected] is Cloudflare's registered abuse mailbox. It's still the wrong place to send a phishing report, because Cloudflare's reporting page says it is "generally unable to process complaints submitted to us by email" and will auto-reply with a link to its form.
The form is worth using. Per Cloudflare's abuse approach page, a report about a site using its CDN or proxy gets forwarded to the website operator and the hosting provider, and the host receives the origin IP so it can find the content. If the site is on Pages or Workers, Cloudflare is the host and can remove it directly.
Tip: The phishing form lets you choose whether your report and your contact details go to the website owner. On a phishing site, the website owner is the attacker. Send it to the host; skip the owner.
So the lookup tells you the right organization, and you still need a small, opinionated table of how each organization wants to be contacted. That table is a per-network fact you learn once and write down:
# Networks whose registered abuse mailbox is not where they want phishing reports.
# Cloudflare says it generally can't process emailed complaints and wants the web form.
FORM_ONLY = {
"AS13335": "https://abuse.cloudflare.com/phishing",
}
def channel_for(net: dict) -> dict:
"""Turn a network record into 'where do I actually send this'."""
form = FORM_ONLY.get(net.get("asn") or "")
if form:
return {"via": "form", "target": form, "note": "Edge network; it forwards to the origin host"}
if net["abuse_emails"]:
return {"via": "email", "target": net["abuse_emails"][0], "note": ""}
return {"via": "manual", "target": None, "note": "No abuse email on record; check the provider's site"}
def group_by_desk(networks: list[dict]) -> dict:
"""One report per abuse desk, listing every IP it answers for. Four IPs, one desk, one report."""
desks: dict[str, dict] = {}
for net in networks:
key = net["send_to"]["target"] or f"manual:{net['asn']}"
desk = desks.setdefault(key, {**net["send_to"], "org": net["abuse_org"], "ips": []})
desk["ips"].append(net["ip"])
return desks
Only Cloudflare is in the table because it's the only one whose policy I verified for this post. Fastly ranked second in the same Interisle quarter with 60,879 attacks, so it's the obvious next entry. Read its abuse page before you add it rather than guessing.
group_by_desk matters more than it looks. For example.com, four IPs collapse into one form submission. The registrars' guide says the same about URLs: group everything on one domain into one report, because one report per URL slows the response and risks duplicates landing in a spam filter. Four near-identical reports don't make action four times more likely; they make every report less readable.
Step 4: Get the registrar from RDAP
WHOIS is the wrong tool now. ICANN made RDAP the definitive source for gTLD registration data on 28 January 2025, and RDAP returns JSON. The rdap.org bootstrap service redirects each query to the authoritative server, so you don't need to know which registry runs which TLD. It rate-limits at 10 requests per 10 seconds, which is plenty for takedowns.
_TLD = tldextract.TLDExtract(suffix_list_urls=())
def registrable_domain(hostname: str) -> str | None:
"""Return the registered domain for RDAP, not an arbitrary subdomain."""
try:
ipaddress.ip_address(hostname)
return None
except ValueError:
pass
extracted = _TLD(hostname)
if not extracted.domain or not extracted.suffix:
return None
name = f"{extracted.domain}.{extracted.suffix}"
return name.encode("idna").decode("ascii")
def _vcard_value(entity: dict, field: str) -> str | None:
"""Pull one field (fn, email, tel) out of an RDAP jCard array."""
vcard = entity.get("vcardArray") or [None, []]
for item in vcard[1]:
if item and item[0] == field and item[-1]:
return item[-1]
return None
def registrar_for(domain: str) -> dict:
"""Registrar name, abuse contact and EPP status via the rdap.org bootstrap."""
try:
resp = requests.get(
f"https://rdap.org/domain/{domain}",
timeout=TIMEOUT,
headers={"Accept": "application/rdap+json"},
)
resp.raise_for_status()
data = resp.json()
except (requests.RequestException, ValueError) as exc:
# ccTLDs without RDAP land here. Fall back to the registry's own WHOIS or website.
return {"error": f"RDAP lookup failed: {exc}"}
result = {"status": data.get("status") or [], "registrar": None,
"abuse_email": None, "abuse_phone": None}
for entity in data.get("entities") or []:
if "registrar" not in (entity.get("roles") or []):
continue
result["registrar"] = _vcard_value(entity, "fn")
for sub in entity.get("entities") or []:
if "abuse" in (sub.get("roles") or []):
result["abuse_email"] = _vcard_value(sub, "email")
result["abuse_phone"] = _vcard_value(sub, "tel")
return result
The registrar's abuse contact sits in an entity nested inside the registrar entity, with role abuse. That nesting is the part people get wrong when they grep RDAP output for the first email address and end up writing to the registrant, who in this situation is the phisher.
Registrars now have a contractual duty here. Since the DNS abuse amendments took effect on 5 April 2024, an ICANN-accredited registrar with actionable evidence of phishing must "promptly take the appropriate mitigation action(s)" to stop or disrupt it. "Promptly" is doing a lot of work in that sentence. The DNS Research Federation measured registry and registrar mitigations from September 2024 to March 2025 and found an average of 8 days, with the share mitigated inside 24 hours rising from 11% to 22%. Report to the registrar, and don't plan around waiting for it.
Step 5: One short report per desk
Everything so far feeds a plan: evidence, desks, registrar, and drafts. Reports stay short and factual, with UTC times and defanged URLs so nobody clicks the link from a ticketing tool.
def defang(url: str) -> str:
"""Make the URL unclickable in mail clients and ticketing tools."""
return url.replace("https://", "hxxps://").replace("http://", "hxxp://").replace(".", "[.]")
def draft_report(evidence: dict, brand: str, recipient_role: str,
notes: list[str] | None = None) -> str:
url = defang(evidence["reported_url"])
lines = [
f"Subject: Phishing site impersonating {brand}: {url}",
"",
f"The URL below is a credential-phishing page impersonating {brand}, served from your {recipient_role}.",
"",
f"URL: {url}",
f"Observed (UTC): {evidence['captured_at_utc']}",
f"HTTP status at capture: {evidence.get('status', 'fetch failed')}",
f"SHA-256 of served page: {evidence.get('body_sha256', 'n/a')}",
f"Impersonated brand: {brand}. We are the brand owner.",
"Attached: screenshots of the phishing page and of our real page, address bars visible.",
*(notes or []),
"",
"Please disable the content and confirm the action taken.",
]
return "\n".join(lines)
def plan(
url: str,
brand: str,
request_domain_suspension: bool = False,
) -> dict:
host = urlsplit(url).hostname or ""
registered = registrable_domain(host)
evidence = capture_evidence(url)
networks = []
for ip in resolve_all(host):
net = network_for(ip)
if net:
net["send_to"] = channel_for(net)
networks.append(net)
if request_domain_suspension:
registrar_notes = [
"Desired outcome: suspension of the registered domain (clientHold).",
f"Also reported to the hosting network at "
f"{evidence['captured_at_utc']}.",
]
else:
registrar_notes = [
"Desired outcome: investigate the reported URL and notify the "
"registrant. Suspend the domain only if the domain itself was "
"registered for abuse.",
f"Also reported to the hosting network at "
f"{evidence['captured_at_utc']}.",
]
return {
"evidence": evidence,
"host_desks": group_by_desk(networks),
"registrar": (
registrar_for(registered)
if registered
else {"error": "The URL has no registrable domain."}
),
"blocklists": [
"https://safebrowsing.google.com/safebrowsing/report_phish/",
"https://www.microsoft.com/en-us/wdsi/support/report-unsafe-site",
"https://report.netcraft.com/",
"https://apwg.org/reportphishing/",
],
"host_report": draft_report(evidence, brand, "network"),
"registrar_report": draft_report(
evidence,
brand,
"registrar's domain",
notes=registrar_notes,
),
}
if __name__ == "__main__":
valid = len(sys.argv) in (3, 4) and (
len(sys.argv) == 3
or sys.argv[3] == "--request-domain-suspension"
)
if not valid:
sys.exit(
"usage: python takedown.py <phishing-url> <your-brand> "
"[--request-domain-suspension]"
)
print(json.dumps(
plan(
sys.argv[1],
sys.argv[2],
request_domain_suspension=len(sys.argv) == 4,
),
indent=2,
))
Install the dependencies with pip install requests tldextract. Run the normal compromised-site workflow as python takedown.py "https://login.example.com/signin" "ExampleCorp". Add --request-domain-suspension only after a human has determined that the registered domain itself was created for abuse rather than being a compromised legitimate site. Against example.com, host_desks comes back with a single entry: the Cloudflare form, listing all four IPs. The evidence block shows Server: cloudflare and a CF-RAY header, which matches the lookup.
The template is deliberately boring. Abuse desks triage a lot of mail, and the reports that get actioned are the ones a person can verify in under a minute: one URL, one time, one claim, one screenshot.
Block it while the removal is pending
Removal takes hours to days. Every guide on how to report a phishing website starts with these forms, and they deserve the spot for one reason: browsers check them before rendering a page, so they protect users sooner. Submit to all four in the plan at the same time as the host and registrar reports.
- Google Safe Browsing feeds warnings in Chrome and other browsers that use it.
- Microsoft's unsafe-site report covers SmartScreen in Edge and Windows.
- Netcraft runs its own takedown and blocklist pipeline.
- APWG takes the original phishing email at [email protected]. Forward it as an attachment so the headers survive. None of these remove the site. Blocking reduces how many people reach it while the parties who can remove it work through their queues.
When the host doesn't answer
Give a host 24 hours, then follow up once on the same thread. If that fails, the next lever depends on how big the host is, and the ASN data tells you.
ASN_URL = "https://api.ipgeolocation.io/v3/asn"
def upstreams_for(ip: str) -> list[dict]:
"""Transit providers of the network hosting this IP. Escalation path for small hosts."""
params = {"apiKey": API_KEY, "ip": ip, "include": "upstreams"}
try:
resp = requests.get(ASN_URL, params=params, timeout=TIMEOUT)
resp.raise_for_status()
data = resp.json()
except requests.HTTPError as exc:
# Do not print the exception object: it may contain the API key.
status = (
exc.response.status_code
if exc.response is not None
else "unknown"
)
print(
f"ASN lookup failed for {ip}: HTTP {status}",
file=sys.stderr,
)
return []
except requests.RequestException as exc:
print(
f"ASN lookup failed for {ip}: {type(exc).__name__}",
file=sys.stderr,
)
return []
except ValueError:
print(
f"ASN lookup failed for {ip}: invalid JSON",
file=sys.stderr,
)
return []
asn = data.get("asn") or {}
return asn.get("upstreams") or []
If you're pasting along, put this and the next helper above the __main__ block. Each upstream comes back as as_number, description, and country. The count is the useful part. When I pulled DigitalOcean's AS14061, the response listed 95 upstreams, so no single transit provider is going to lean on it over one phishing page; the host's own abuse desk is the only lever there. A small host with two upstreams is a different story, and their abuse desks are worth a polite, evidence-first note. The ASN pivot playbook covers reading routes and upstreams in more depth.
For providers abroad that ignore the direct reports, a relevant national CERT can be an escalation path. Choose it from the confirmed provider or origin-host jurisdiction, not from the geolocation of a CDN edge, and verify the contact manually before sending the case.
Confirm it's actually down
A takedown isn't done when someone replies "actioned". Check it yourself at 24 and 72 hours.
def looks_down(domain: str, url: str) -> dict:
"""Re-run at 24 and 72 hours. Any one of these is a takedown signal worth logging."""
registered = registrable_domain(domain)
rdap = (
registrar_for(registered)
if registered
else {"status": [], "error": "The URL has no registrable domain."}
)
held = [
status
for status in rdap.get("status", [])
if status in ("client hold", "server hold")
]
# Reuse the bounded, redirect-aware, public-destination-only fetcher.
probe = capture_evidence(url)
http_status = probe.get("status")
if http_status is None:
http_status = (
f"probe_failed ({probe.get('fetch_error', 'unknown error')})"
)
return {
"dns_resolves": bool(resolve_all(domain)),
"registry_hold": held,
"http_status": http_status,
}
client hold in the RDAP status means the registrar suspended the domain; server hold means the registry did. Those are the same signals the DNS Research Federation used to count mitigations. A 404 or 410 from the host with DNS still resolving means the content is gone but the domain is alive, so keep the registrar report open, because a live domain can serve a new kit tomorrow.
The FORM_ONLY table is the most valuable phishing takedown asset you'll build here, so keep it in version control and add a row every time an abuse desk bounces your email to a form. Store each evidence JSON with the case. Phishing kits get reused, and when the same page hash turns up on a new domain next month, you'll know the captured bytes or kit are the same. That is useful correlation, but it does not by itself prove the same operator is behind both domains.
Originally published by Dev.to Security. Aggregated on AIWithGhost for educational purposes — full credit and traffic to the original publisher.