backlink-guard 0.7.0__py3-none-any.whl

backlink_guard/__init__.py

@@ -0,0 +1,15 @@
+"""backlink-guard: check a link source before you submit to it, and watch your own link profile."""
+import os
+from pathlib import Path
+
+__version__ = "0.7.0"
+UA = f"Mozilla/5.0 (compatible; backlink-guard/{__version__}; +https://github.com/zhuyansen/backlink-guard)"
+
+
+def state_dir() -> Path:
+    """Where the log, the cache and the networks seen before are kept: BACKLINK_GUARD_STATE when set, ./state when
+    it exists (a clone run from its own folder, as before 0.6), else ~/.backlink-guard, so an installed command
+    keeps one log wherever it is run from."""
+    if os.environ.get("BACKLINK_GUARD_STATE"):
+        return Path(os.environ["BACKLINK_GUARD_STATE"])
+    return Path("state") if Path("state").is_dir() else Path.home() / ".backlink-guard"

backlink_guard/__main__.py

@@ -0,0 +1,181 @@
+"""backlink-guard: check a link source before you submit to it, and watch your own links.
+
+  python -m backlink_guard find "<keyword>" [more ...] [--site yoursite.com] [--skip site|file] [--vet] [--limit 30] [--fresh] [--json]
+  python -m backlink_guard vet <site> [more ...] [--from list.xlsx|.csv|.md|.json] [--skip site|file] [--limit 30] [--topic "keyword"] [--referrals ga4.csv] [--deep] [--recent] [--free] [--fresh] [--json]
+  python -m backlink_guard recheck [--to your-domain] [--deep] [--free] [--fresh] [--json]
+  python -m backlink_guard audit <your-domain> [--deep] [--sitewide 20] [--rows 1000] [--fresh] [--json]
+  python -m backlink_guard lost <your-domain> [--sitewide 20] [--rows 1000] [--fresh] [--json]
+  python -m backlink_guard verify <page-url> --to <your-domain> [--json]
+  python -m backlink_guard log                                  the record, with pace and anchor checks
+  python -m backlink_guard log add <site> --kind directory [--anchor TEXT] [--paid USD] [--url URL] [--note TEXT]
+  python -m backlink_guard log set <site> --status live [--url URL]
+
+find    the pages that rank for your keywords (directories, lists, articles, videos,
+        threads), sorted by the visitors they get from those searches, with what can be done
+        on each: $0.005 a keyword plus $0.012 for the search volumes. --vet then vets the sites.
+vet     reads each site, and with keys asks for its rating, a year of visits and its
+        spam score: about $0.01 a site plus $0.025 for the batch. --free reads the site only.
+        --from reads the sites out of a list file; --limit caps how many are checked.
+        --topic adds where each site ranks for your keyword ($0.005 a keyword).
+        --referrals reads your analytics export (GA4 Session source and Sessions) and shows
+        what each site has sent you. A site its own pages put at avoid gets no paid check.
+recheck the sites in your log checked again and compared with the last look: what got
+        worse, and with --to, whether your links are still there. Monthly is enough.
+audit   your own profile: totals, new and lost referring domains by week, anchors with their
+        referring domains, site-wide links (one site linking from many of its pages, counted once),
+        and the spam score of the sites linking to you: about $0.11, with --deep about $0.15.
+lost    links to pages of yours that answer 404 or 410, by referring domains, each with the
+        closest live page in your sitemaps to 301 it to. The same backlinks as audit (about
+        $0.06, nothing more after an audit the same week); asking your pages is free.
+verify  whether a page links to you and whether that link passes ranking credit. Free.
+log     kept in state/ledger.jsonl on this machine. Free.
+
+Keys: GOANYAPI_API_KEY (rating, visits, index, your backlinks) and AISA_API_KEY (spam
+scores, weekly new and lost domains, anchors). Each is optional; what is missing is said.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+
+from pathlib import Path
+
+from . import find as finding
+from . import ledger, links, lists, lost, page, profile, recheck, report
+from . import verify as verification
+from . import vet as vetting
+
+LIMIT = 30          # sites a run checks unless told otherwise: about $0.30 with both keys
+
+
+def _print(args, data, text: str) -> int:
+    print(json.dumps(data, ensure_ascii=False, indent=1, default=sorted) if args.json else text)
+    return 0
+
+
+def skipped(args) -> set[str]:
+    return {page.site(x) for s in args.skip for x in (lists.read(s) if Path(s).is_file() else [s])}
+
+
+def cmd_find(args) -> int:
+    result = finding.find(args.keywords, own=args.site or "", skip=tuple(skipped(args)), fresh=args.fresh)
+    vetted = {}
+    if args.vet:
+        sites = finding.to_vet(result, args.limit)
+        checked = vetting.vet(sites, fresh=args.fresh, topics=tuple(args.keywords)) if sites else {"rows": [], "cost": 0, "errors": []}
+        result["vet"], result["cost"] = checked, result["cost"] + checked["cost"]
+        vetted = {r["domain"]: r["grade"] for r in checked["rows"]}
+    text = report.find(result, vetted)
+    if args.vet and result["vet"]["rows"]:
+        text += "\n\n" + report.vet(result["vet"])
+    return _print(args, result, text)
+
+
+def targets_of(args) -> list[str]:
+    """The sites given and the sites in --from, once each, at most --limit of them."""
+    skip = skipped(args)
+    found = [t for t in dict.fromkeys(args.targets + (lists.read(args.from_file) if args.from_file else []))
+             if page.site(t) not in skip]
+    if not found:
+        raise SystemExit("vet: give sites, or a list with --from")
+    if len(found) > args.limit:
+        print(f"{len(found)} sites found; checking the first {args.limit} (raise --limit to check more)", file=sys.stderr)
+    return found[:args.limit]
+
+
+def cmd_log(args) -> int:
+    if args.action == "add":
+        if not args.site or not args.kind:
+            raise SystemExit("log add: give the site and --kind")
+        ledger.add(args.site, args.kind, args.anchor or "", args.paid or 0.0, args.url or "", args.note or "")
+    elif args.action == "set":
+        if not ledger.update(args.site or "", status=args.status, url=args.url, note=args.note):
+            raise SystemExit(f"log set: no entry for {args.site}")
+    rows = ledger.entries()
+    flags = ledger.checks(rows)
+    return _print(args, {"entries": rows, "flags": flags}, report.ledger(rows, flags))
+
+
+def parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(prog="python -m backlink_guard", description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    sub = p.add_subparsers(dest="command", required=True)
+    common = argparse.ArgumentParser(add_help=False)
+    common.add_argument("--json", action="store_true")
+    common.add_argument("--fresh", action="store_true", help="ignore answers cached in the last 7 days")
+    f = sub.add_parser("find", parents=[common])
+    f.add_argument("keywords", nargs="+", metavar="KEYWORD")
+    f.add_argument("--site", metavar="DOMAIN", help="your own site, left out of the results")
+    f.add_argument("--skip", action="append", default=[], metavar="SITE_OR_FILE",
+                   help="leave out these sites (competitors, ones you already have); repeatable, or a list file")
+    f.add_argument("--vet", action="store_true", help="also vet the directories and article sites found (about $0.01 a site)")
+    f.add_argument("--limit", type=int, default=LIMIT, help=f"vet at most this many sites (default {LIMIT})")
+    v = sub.add_parser("vet", parents=[common])
+    v.add_argument("targets", nargs="*")
+    v.add_argument("--from", dest="from_file", metavar="FILE", help="a list to read sites from (.txt .md .csv .json .xlsx)")
+    v.add_argument("--limit", type=int, default=LIMIT, help=f"check at most this many sites (default {LIMIT})")
+    v.add_argument("--skip", action="append", default=[], metavar="SITE_OR_FILE",
+                   help="leave out these sites (your own, competitors, ones you already have); repeatable, or a list file")
+    v.add_argument("--free", action="store_true", help="read the sites only; call no paid API")
+    v.add_argument("--deep", action="store_true",
+                   help="also read each site's own backlink profile: badge networks, unproven sites (+$0.024 a site)")
+    v.add_argument("--topic", action="append", default=[], metavar="KEYWORD",
+                   help="your keyword: shows where each site ranks for it (+$0.005 a keyword); repeatable")
+    v.add_argument("--recent", action="store_true",
+                   help="also ask whether Google took in the site's pages from the last week and month (+$0.008 a site, slow)")
+    v.add_argument("--referrals", metavar="FILE",
+                   help="your analytics export of visitor sources (GA4 CSV: Session source, Sessions): shows what each site sent you")
+    r = sub.add_parser("recheck", parents=[common])
+    r.add_argument("--to", metavar="DOMAIN", default="", help="your domain: also check that your links are still there (free)")
+    r.add_argument("--deep", action="store_true", help="also the backlink profile of each site (+$0.024 a site)")
+    r.add_argument("--free", action="store_true", help="read the sites only; call no paid API")
+    a = sub.add_parser("audit", parents=[common])
+    a.add_argument("domain")
+    a.add_argument("--deep", action="store_true", help="also the full anchor distribution")
+    o = sub.add_parser("lost", parents=[common])
+    o.add_argument("domain")
+    for x in (a, o):
+        x.add_argument("--sitewide", type=int, default=links.SITEWIDE_PAGES, metavar="PAGES",
+                       help=f"pages of one site linking to one page of yours that make a site-wide link (default {links.SITEWIDE_PAGES})")
+        x.add_argument("--rows", type=int, default=links.ROWS, metavar="LINKS",
+                       help=f"backlinks read one by one from AIsa (default and most {links.ROWS}; about $0.06 for 1,000)")
+    c = sub.add_parser("verify", parents=[common])
+    c.add_argument("page")
+    c.add_argument("--to", required=True, metavar="DOMAIN")
+    g = sub.add_parser("log", parents=[common])
+    g.add_argument("action", nargs="?", choices=["add", "set"])
+    g.add_argument("site", nargs="?")
+    g.add_argument("--kind", choices=ledger.KINDS)
+    g.add_argument("--status", choices=ledger.STATUSES)
+    for name in ("--anchor", "--url", "--note"):
+        g.add_argument(name)
+    g.add_argument("--paid", type=float)
+    return p
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = parser().parse_args(argv)
+    if args.command == "vet":
+        targets = targets_of(args)
+        result = vetting.vet(targets, paid_sources=not args.free, fresh=args.fresh, recent=args.recent, deep=args.deep,
+                             topics=tuple(args.topic), referrals=lists.referrals(args.referrals) if args.referrals else None)
+        return _print(args, result, report.vet(result))
+    if args.command == "recheck":
+        result = recheck.run(own=args.to, paid_sources=not args.free, deep=args.deep, fresh=args.fresh)
+        return _print(args, result, report.recheck(result))
+    if args.command == "find":
+        return cmd_find(args)
+    if args.command == "audit":
+        result = profile.audit(args.domain, deep=args.deep, fresh=args.fresh, sitewide=args.sitewide, rows=args.rows)
+        return _print(args, result, report.audit(result))
+    if args.command == "lost":
+        result = lost.lost(args.domain, fresh=args.fresh, rows=args.rows, sitewide=args.sitewide)
+        return _print(args, result, report.lost(result))
+    if args.command == "verify":
+        result = verification.verify(args.page, args.to)
+        return _print(args, result, report.verify(result))
+    return cmd_log(args)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

backlink_guard/aisa.py

@@ -0,0 +1,85 @@
+"""AIsa's tool router: backlink data (spam score, new and lost referring
+domains, anchors). Key: AISA_API_KEY, or the one the AIsa CLI stores at login.
+
+Every call is billed and none is retried here. Prices seen on 2026-10-13: spam score for
+14 domains in one call $0.025, a new/lost timeline $0.025, anchors about $0.04.
+"""
+from __future__ import annotations
+
+import json
+import os
+import urllib.error
+import urllib.request
+from pathlib import Path
+
+from . import UA
+
+ROUTER = os.environ.get("AISA_ROUTER_BASE_URL", "https://tools.aisa.one") + "/v1/tool-router/aisa-batch-use"
+# AIsa's passthrough to the same endpoints, as they are: the router's schema refuses their array
+# filters ("got array, want null or object", 2026-10-15), this path takes them.
+REST = os.environ.get("AISA_API_BASE_URL", "https://api.aisa.one") + "/apis/v1/dataforseo/"
+TIMEOUT = 240
+
+
+class AisaError(RuntimeError):
+    pass
+
+
+def key() -> str:
+    """"" when there is no key: callers skip this source, they do not fail."""
+    if os.environ.get("AISA_API_KEY"):
+        return os.environ["AISA_API_KEY"].strip()
+    stored = Path.home() / ".aisa" / "key"
+    return stored.read_text().strip() if stored.exists() else ""
+
+
+def _run(tool: str, arguments: dict) -> tuple[object, int]:
+    """One call through the tool router: (its data, cost in micro-USD)."""
+    payload = {"calls": [{"call_id": "c", "tool": tool, "arguments": arguments}]}
+    req = urllib.request.Request(ROUTER, data=json.dumps(payload).encode(), method="POST", headers={
+        "Content-Type": "application/json", "Authorization": f"Bearer {key()}", "User-Agent": UA,
+        "x-aisa-source": "backlink-guard"})
+    try:
+        with urllib.request.urlopen(req, timeout=TIMEOUT) as res:
+            reply = json.load(res)
+    except urllib.error.HTTPError as exc:
+        raise AisaError(f"HTTP {exc.code}: {' '.join(exc.read().decode('utf-8', 'replace').split())[:160]}") from exc
+    except (OSError, ValueError) as exc:
+        raise AisaError(f"{type(exc).__name__}: {exc}") from exc
+    row = (reply.get("results") or [{}])[0]
+    if "error" in reply or not row.get("successful"):
+        raise AisaError(str(reply.get("error") or row.get("error") or "call failed")[:160])
+    return row.get("data"), int(row.get("customer_cost_micros_usd") or 0)
+
+
+def tool(name: str, arguments: dict) -> tuple[object, int]:
+    """A tool whose answer is not a task list (Ahrefs, Semrush): its data as the router returns it."""
+    return _run(name, arguments)
+
+
+def call(tool: str, body: dict) -> tuple[dict, int]:
+    """One AIsa task. Returns (the task's first result, cost in micro-USD)."""
+    data, cost = _run(tool, {"body": [body]})
+    task = (((data or {}) if isinstance(data, dict) else {}).get("tasks") or [{}])[0]
+    if not task.get("result"):
+        raise AisaError(str(task.get("status_message") or "no result")[:160])
+    return task["result"][0] or {}, cost
+
+
+def rest(path: str, body: dict) -> tuple[dict, int]:
+    """One live task through AIsa's passthrough: (its first result, cost in micro-USD)."""
+    req = urllib.request.Request(REST + path, data=json.dumps([body]).encode(), method="POST", headers={
+        "Content-Type": "application/json", "Authorization": f"Bearer {key()}", "User-Agent": UA,
+        "x-aisa-source": "backlink-guard"})
+    try:
+        with urllib.request.urlopen(req, timeout=TIMEOUT) as res:
+            reply = json.load(res)
+    except urllib.error.HTTPError as exc:
+        raise AisaError(f"HTTP {exc.code}: {' '.join(exc.read().decode('utf-8', 'replace').split())[:160]}") from exc
+    except (OSError, ValueError) as exc:
+        raise AisaError(f"{type(exc).__name__}: {exc}") from exc
+    task = (reply.get("tasks") or [{}])[0]
+    if reply.get("status_code") != 20000 or task.get("status_code") != 20000:
+        raise AisaError(str(task.get("status_message") or reply.get("status_message") or "call failed")[:160])
+    cost = float(reply.get("cost") or task.get("cost") or 0)
+    return (task.get("result") or [{}])[0] or {}, int(round(cost * 1e6))

backlink_guard/blocklist.py

@@ -0,0 +1,82 @@
+"""The shared list of sites that build or sell spam backlinks, each with public evidence
+(github.com/zhuyansen/backlink-spam-list). A site listed there is avoid, with the entry's evidence.
+Read once a run and kept a day; free. A list that cannot be read is reported, never read as empty.
+The list grows by reports: a check that finds one operator's sites missing from it links to a filled-in report.
+"""
+from __future__ import annotations
+
+import csv
+import io
+import os
+import urllib.request
+from datetime import date
+from urllib.parse import quote, urlencode
+
+from . import UA, __version__, cache
+from .policy import flag
+
+URL = os.environ.get("BACKLINK_SPAM_LIST_URL", "https://raw.githubusercontent.com/zhuyansen/backlink-spam-list/main/list.csv")
+REPORT_FORM = os.environ.get("BACKLINK_SPAM_LIST_REPORT", "https://github.com/zhuyansen/backlink-spam-list/issues/new")
+NETWORK = "link-network (one operator's sites - a shared template, redirect, checkout link or account)"   # the form's option
+TTL_DAYS = 1
+TIMEOUT = 20
+REPORT_MIN = 3                  # sites one operator's group needs before it is worth a report
+REPORT_SITES = 30               # sites one report carries at most
+OPERATOR = {"same_template", "same_owner"}     # findings that only say one operator runs the sites
+
+
+def load(fresh: bool = False) -> dict[str, dict]:
+    """{domain: entry} for the entries still listed. Raises OSError or ValueError when the list cannot be read."""
+    held = None if fresh else cache.get(f"spamlist:{URL}", ttl_days=TTL_DAYS)
+    if held is not None:
+        return held
+    with urllib.request.urlopen(urllib.request.Request(URL, headers={"User-Agent": UA}), timeout=TIMEOUT) as res:
+        text = res.read().decode("utf-8")
+    rows = csv.DictReader(io.StringIO(text))
+    held = {r["domain"]: {k: r.get(k, "") for k in ("category", "family", "evidence", "evidence_url", "last_checked")}
+            for r in rows if r.get("status") == "listed"}
+    cache.put(f"spamlist:{URL}", held)
+    return held
+
+
+def flag_for(domain: str, listed: dict[str, dict]) -> dict | None:
+    e = listed.get(domain)
+    if not e:
+        return None
+    family = f", the {e['family']} family" if e.get("family") else ""
+    return flag("listed", f"{e['category']}{family}: {e['evidence'][:180]} ({e['evidence_url']}, checked {e['last_checked']})")
+
+
+def against(row: dict) -> bool:
+    """Something stands against the site besides sharing an operator, which a company's honest sites also do."""
+    return any(f["level"] in ("avoid", "caution") and f["flag"] not in OPERATOR for f in row["flags"])
+
+
+def unlisted(groups: list[dict], rows: list[dict], listed: dict[str, dict] | None, today: date) -> list[dict]:
+    """The groups of one operator's sites (vet.shared_templates, vet.shared_owners) worth a report: REPORT_MIN sites
+    or more, at least half of those in this check with a finding against them besides the shared operator, and
+    some not listed yet. Each with the link to a filled-in report. None when the list could not be read."""
+    if listed is None:
+        return []
+    by_site, out = {r["domain"]: r for r in rows}, []
+    for g in groups:
+        checked = [d for d in g["sites"] if d in by_site]
+        flagged = [d for d in checked if against(by_site[d])]
+        missing = [d for d in g["sites"] if d not in listed]
+        if len(g["sites"]) >= REPORT_MIN and missing and 2 * len(flagged) >= len(checked):
+            out.append({**g, "unlisted": missing, "report": report_url(g, missing, today)})
+    return out
+
+
+def report_url(group: dict, sites: list[str], today: date) -> str:
+    """The list's report form, filled in: the first site, the others as members, what they share. Opening it sends
+    nothing; the reporter reads it and submits, and a maintainer checks the evidence before anything is listed."""
+    shown = sites[:REPORT_SITES]
+    shared = (f"{len(group['sites'])} sites share one page title, each site's own name taken out: \"{group['key']}\""
+              if group["kind"] == "template" else
+              f"{len(group['sites'])} sites report to one analytics or ads account: {group['key']}")
+    fields = {"template": "report.yml", "title": f"Report: {shown[0]}" + (f" and {len(shown) - 1} more" if len(shown) > 1 else ""),
+              "domain": shown[0], "category": NETWORK, "evidence-url": f"https://{shown[0]}/", "evidence": shared,
+              "members": "\n".join(shown[1:]),
+              "context": f"Found with backlink-guard {__version__} on {today.isoformat()}: the sites came up in checks together."}
+    return f"{REPORT_FORM}?{urlencode(fields, quote_via=quote)}"

backlink_guard/cache.py

@@ -0,0 +1,36 @@
+"""Paid answers kept on disk for a few days, so checking the same site twice in a week
+is paid for once. One JSON file per question under <state>/cache/."""
+from __future__ import annotations
+
+import hashlib
+import json
+import time
+from pathlib import Path
+
+from . import state_dir
+
+DAY = 86400
+TTL_DAYS = 7
+
+
+def _dir() -> Path:
+    return state_dir() / "cache"
+
+
+def _path(key: str) -> Path:
+    return _dir() / (hashlib.sha1(key.encode()).hexdigest()[:20] + ".json")
+
+
+def get(key: str, ttl_days: float = TTL_DAYS):
+    path = _path(key)
+    if not path.exists() or time.time() - path.stat().st_mtime > ttl_days * DAY:
+        return None
+    try:
+        return json.loads(path.read_text())
+    except ValueError:
+        return None
+
+
+def put(key: str, value) -> None:
+    _dir().mkdir(parents=True, exist_ok=True)
+    _path(key).write_text(json.dumps(value, ensure_ascii=False))

backlink_guard/checkout.py

@@ -0,0 +1,160 @@
+"""Checkout links shared across sites (0.5, from the payment-link history of 2026-10-15).
+
+A checkout link (a Stripe Payment Link, a Gumroad product, Lemon Squeezy, Polar, Creem, Dodo or
+Paddle) belongs to one seller. When the one a site carries also sits on many other sites, either
+one operator's network sells through it or it was injected into hacked sites. On 2026-10-15 one
+Stripe link sat on 395 sites titled like "Backlink Generator Tool" and "SEO Score Checker", and a
+Gumroad link for an escort service had been injected into 262 schools, clinics and museums. A
+product people write about is shared too (MacWhisper's link sat on 705 sites), by sites that look
+nothing alike: that is not flagged.
+
+Network sites put their checkout links on a few of thousands of inner pages (/dir/<slug>-<id>),
+which no sample of pages finds (six sitemap pages of two network sites held none). So the home page
+is read for free, and with --deep AIsa also lists the site's links to Stripe and Gumroad, the
+platforms of nearly every shared link (one call each, about $0.024). One more call per checkout link
+found (about $0.02), at most LOOKED_AT per site; most link sources carry none and cost little.
+"""
+from __future__ import annotations
+
+import re
+from collections import Counter
+from concurrent.futures import ThreadPoolExecutor
+
+from . import aisa, page
+from .policy import flag
+
+TOOL = "post_dataforseo_backlinks_backlinks_live"
+CHECKOUT = re.compile(r"https?://(?:buy\.stripe\.com/[A-Za-z0-9_]+|(?:[a-z0-9-]+\.)?gumroad\.com/l/[^/?#\s]+|"
+                      r"[a-z0-9-]+\.lemonsqueezy\.com/(?:checkout/)?buy/[^/?#\s]+|buy\.polar\.sh/[^/?#\s]+|"
+                      r"(?:www\.)?creem\.io/payment/[^/?#\s]+|checkout\.dodopayments\.com/buy/[^/?#\s]+|"
+                      r"buy\.paddle\.com/[^?#\s]+)", re.I)
+LOOKED_AT = 2           # checkout links looked up per site
+LIMIT = 100             # other sites read per checkout link
+SHARED_MIN = 5          # other sites carrying the same link before it means anything
+TEMPLATE_SHARE = 0.4    # this share of those sites' titles alike (same ending, or about selling links)
+TAIL_WORDS = 2          # "drjack.world | Keyword Rankingss": the site's name sits right before the template's words
+TITLES_READ = 24        # AIsa's rows leave most page titles empty: this many home pages are read for theirs
+MIRRORS_MAX = 20        # up to this many sites with one identical title can be one site on several domains (17 seen)
+INJECTED_RELATED = 0.3  # a gambling or adult product cited by sites on its own topic is promotion, not injection
+PLATFORMS = ("stripe.com", "gumroad.com")     # with --deep: where the site's own checkout links are looked for
+LINKED = 20             # of the site's links to each
+# What the network sites of 2026-10-15 were titled: SEO tools and link sales, one template per site.
+LINK_TRADE = re.compile(r"\bbacklinks?\b|\blink building\b|\bguest posts?\b|\bkeyword ranking|\bchecker\b|\bpbn\b|"
+                        r"\b(?:traffic|backlink) generator\b|\bda\s*pa\b|\baged domains?\b|\bdomain authority\b", re.I)   # not "seo": SEO blogs cite SEO courses
+# Words of the products injected into hacked sites, besides the gambling and adult words vet already has.
+INJECTED = re.compile(r"\b(?:travesti|bahis|bokep|jav|call ?girls?|escorts?)\b", re.I)
+
+
+def links_on(links: list[dict]) -> list[str]:
+    """The checkout links among `links`, query strings dropped, the first LOOKED_AT in page order."""
+    found: list[str] = []
+    for link in links:
+        m = CHECKOUT.match(link["href"])
+        url = m.group(0).rstrip("/") if m else ""
+        if url and url not in found:
+            found.append(url)
+    return found[:LOOKED_AT]
+
+
+def linked(site: str, ask) -> tuple[list[dict], int]:
+    """With --deep: the site's links to PLATFORMS, as page links ({"href"}), and the cost."""
+    found, cost = [], 0
+    for target in PLATFORMS:
+        data, spent = ask(f"checkout-from:{site}:{target}", lambda target=target: aisa.rest("backlinks/backlinks/live", {
+            "target": target, "mode": "as_is", "limit": LINKED, "backlinks_status_type": "live",
+            "filters": [["domain_from", "like", f"%{site}"]]}))
+        found += [{"href": i.get("url_to") or ""} for i in (data or {}).get("items") or []]
+        cost += spent
+    return found, cost
+
+
+def others(url: str, own: str, ask) -> tuple[list[dict], int]:
+    """The other sites linking to `url`: [{"site", "title"}] (one row a site), and the cost."""
+    try:
+        data, cost = ask(f"checkout:{url}", lambda: aisa.call(TOOL, {
+            "target": url, "mode": "one_per_domain", "limit": LIMIT, "backlinks_status_type": "live"}))
+    except aisa.AisaError as exc:
+        if "no result" in str(exc).lower():         # nobody links to it: nothing shared
+            return [], 0
+        raise
+    rows, seen = [], {own}
+    for item in (data or {}).get("items") or []:
+        site = page.site("https://" + (item.get("domain_from") or ""))
+        if site and site not in seen:
+            seen.add(site)
+            rows.append({"site": site, "title": item.get("page_from_title") or "", "host": item.get("domain_from") or site})
+    return titled(rows), cost
+
+
+def titled(rows: list[dict]) -> list[dict]:
+    """Rows with a title: the ones AIsa left empty read from their home pages, TITLES_READ at most."""
+    blank = [r for r in rows if not r["title"].strip()][:TITLES_READ]
+    with ThreadPoolExecutor(12) as pool:
+        for r, got in zip(blank, pool.map(lambda r: page.fetch(f"https://{r['host']}/"), blank)):
+            r["title"] = page.parse(got["html"], got["final"])["title"] if got["html"] else ""
+    return rows
+
+
+def tail(title: str) -> str:
+    words = re.findall(r"[a-z0-9]+", title.lower())
+    return " ".join(words[-TAIL_WORDS:]) if len(words) > TAIL_WORDS else ""
+
+
+def judge(url: str, own_title: str, rows: list[dict], spam: re.Pattern) -> dict | None:
+    """A flag when the site is one of many carrying `url` and is like them: titled about link sales, or built
+    from the same template, or one of the unrelated sites a spam product was injected into. A site whose
+    link was merely copied onto such sites (the seller's own, or one that cites the product) is not flagged.
+    Counted by site: on 2026-10-15, 94-99 of the 100 sites carrying each of three network links shared one
+    title ("Expert backlink building services for higher Google rankings..."). A few sites with one identical
+    title are more likely one site on several domains, which a template needs more of (MIRRORS_MAX) to count."""
+    n = len(rows)
+    if n < SHARED_MIN:
+        return None
+    count = f"{n}{'+' if n >= LIMIT else ''}"
+    examples = ", ".join(r["site"] for r in rows[:3])
+    own = " ".join(own_title.lower().split())
+    titles = [" ".join(r["title"].lower().split()) for r in rows if r["title"].strip()]
+    need = max(SHARED_MIN, TEMPLATE_SHARE * len(titles))
+    if spam.search(url) or INJECTED.search(url):
+        related = sum(1 for t in titles if spam.search(t) or INJECTED.search(t))
+        if related < INJECTED_RELATED * len(titles) and not (spam.search(own) or INJECTED.search(own)):
+            return flag("injected_checkout", f"{url} also sits on {count} other unrelated sites, e.g. {examples}")
+        return None
+    trade = sum(1 for t in titles if LINK_TRADE.search(t))
+    if trade >= need and LINK_TRADE.search(own) and len(set(titles)) > 1 or trade >= max(need, MIRRORS_MAX + 1) and LINK_TRADE.search(own):
+        return flag("checkout_network", f"{url} also sits on {count} other sites; {trade} of them are titled about "
+                                        f"backlinks, link checkers or link sales, like this one, e.g. {examples}")
+    by_tail: dict[str, list[str]] = {}
+    for t in titles:
+        if tail(t):
+            by_tail.setdefault(tail(t), []).append(t)
+    ending, group = max(by_tail.items(), key=lambda kv: len(kv[1]), default=("", []))
+    template = len(set(group)) >= 3 or len(group) > MIRRORS_MAX
+    if len(group) >= need and template and tail(own) == ending:
+        return flag("checkout_network", f"{url} also sits on {count} other sites; {len(group)} of their titles end "
+                                        f"\"…{ending}\" like this one's, e.g. {examples}")
+    return None
+
+
+def shared(read: dict, own: str, ask, spam: re.Pattern, deep: bool = False) -> tuple[list[dict], int, list[str]]:
+    """(flags, cost, errors) for the checkout links on a site read by vet.read_site; with `deep`, also the ones
+    AIsa saw on its other pages."""
+    flags, cost, errors = [], 0, []
+    links = list(read["parsed"]["links"])
+    if deep:
+        try:
+            more, cost = linked(own, ask)
+            links += more
+        except aisa.AisaError as exc:
+            errors.append(f"checkout links: {exc}")
+    for url in links_on(links):
+        try:
+            rows, spent = others(url, own, ask)
+        except aisa.AisaError as exc:
+            errors.append(f"checkout link {url}: {exc}")
+            continue
+        cost += spent
+        found = judge(url, read["parsed"]["title"], rows, spam)
+        if found and found["flag"] not in {f["flag"] for f in flags}:        # one flag of a kind, the first link's evidence
+            flags.append(found)
+    return flags, cost, errors