# Opt-out method playbooks How the agent executes each broker `optout.method` using native Hermes tools. Obey **least-disclosure**: submit only the subject's OWN identifiers, and only the fields a broker's official channel requires (`pdd.py plan` lists them per broker). Never disclose more than that, and confirm a listing is really the subject's before acting on any THIRD-PARTY / indirect record (see "Distinguish the subject" and "Indirect exposure"). See the posture section below for when a confirmed listing is NOT a prerequisite. **Autonomy:** `pdd.py next ` sequences all of this - it decides which method applies, orders parents first, and routes human-only work to the digest. In `autonomy=full` (default), execute its actions without pausing per submission; the consent recorded at intake is the authorization (an action with `confirm_first: true`, such as `dnc_register`, still waits for the operator). These playbooks are the HOW for each action type. ## Opt-out posture: blind opt-out is the default (not a fallback) Operator-directed posture: **submit an opt-out or deletion on EVERY site that exposes an accessible removal channel, even when a listing was not first confirmed** - whichever of opt-out / deletion is optimal per site. Do not hand back a to-do list of "we could not search these." - **Why it is sound (does NOT violate least-disclosure):** a blind opt-out sends only the subject's own identifiers to the broker's own official removal channel. You are giving the broker the subject's data *to remove it*, not exposing new data or acting on a third party. (Third-party / indirect records are the exception: those still require confirming the exposure first.) - **The opt-out flow doubles as the authoritative search.** Guided flows that match on email + DOB + legal name and then say "no results" are a **stronger `not_found` than any scrape** - the broker ran its own matcher against real identifiers. On guided-flow sites, "run the opt-out" and "search" are one action (e.g. CheckPeople; see `site-playbooks.md`). ### Blocked form -> default to the cited rights-email (the headline rule) When a removal **form** is automation-hostile (hard CAPTCHA, a Cloudflare wall that will not clear, a JS paywall funnel), **default to the broker's cited rights-request email** rather than recording `blocked` and deferring to a human - unless there is an easy in-browser solve. Decision order per site: 1. **Easy in-browser solve?** (one-click remove; a guided flow whose CAPTCHA auto-clears on the residential browser; plain email-verify) -> do it in the browser. 2. **Form blocked but a cited rights-email exists?** -> send a deletion/opt-out email from the operator's webmail (name + state + contact email only). This is now **preferred** over recording `blocked`. 3. **No easy solve AND no cited email** -> `blocked` (or `human_task_queued` with the exact end-state). 4. **Only lane requires gov-ID / physical mail** -> do NOT pursue autonomously (least-disclosure); surface as a human decision. "Cited" = published by the broker itself (privacy policy / opt-out page / a working deletion alias). Do **not** email addresses sourced only from third-party blogs or Reddit. Per-site lanes and gotchas are pre-recorded in `references/site-playbooks.md` so future runs execute rather than re-derive. ### Triage an external OSINT list before scanning When cross-checking any external "people OSINT" catalog, separate **first-party brokers** (removal targets) from **meta-search / link-out aggregators** (no first-party data -> no-ops, do not file opt-outs), **cluster front-ends** (covered by a parent, e.g. addresses.com -> Intelius), and **non-broker tools / APIs / wrong-jurisdiction** (skip). The skip-lists live in `site-playbooks.md`. ## Scan ladder (all methods) Build the exposure map cheapest first (on a site with an accessible removal channel you may still blind-opt-out even if the scan is inconclusive - see the posture section above). Run **every** `search_vectors` entry from `pdd.py plan` (each name x location, phone, email, and address the broker's `search.by` supports) - different vectors surface different listings for the same person; dedupe found URLs. 1. `web_extract` on the broker `search.url` (fast HTML -> markdown). Look for `search.match_signal`. Build per-vector URLs from `search.url_patterns` and heed `search.url_format_quirks` (see below). 1b. **`site:` search-engine probe (cheap, do it early and in parallel).** `web_search` with `site: "First Last"` (add a city/ZIP or a unique phone/address to cut namesake noise) often returns the **exact profile-slug URL** in one shot - which both confirms the listing exists AND hands you the opaque `/find/person/` or `/p/` URL you'd otherwise have to derive. Two big wins seen in the field: (a) it disambiguates namesakes fast - the SERP snippet shows age/city so you can tell the subject from a same-name relative before fetching anything; and (b) a broad `"First Last" ` search (no `site:`) surfaces **brokers not yet in your DB** (e.g. information.com, peoplefinders.com) - record those as bonus exposures. Note: empty `site:` results are INCONCLUSIVE (many broker pages aren't indexed / are `noindex`), not `not_found`. 2. If the page is JS-rendered or returns nothing useful, use `browser_exec`: `new_tab(url)` + `wait_for_load()`, then `page_info()` / `js()` to read the results (`fill_input()` + a `js()` click to run the site's search box). 3. If blocked by stealth/Cloudflare, use the `scrapling` skill via `terminal`. **If the broker record has `search.antibot` set (e.g. `datadome`), results are behind a device-check CAPTCHA**: a cloud/stealth browser (Browserbase) or `scrapling` may get through; if none is available, do **not** burn attempts - `pdd.py record blocked` and move on (a re-scan with a stealth backend can pick it up later). 3b. **Operator-browser path (the reliable unblock for anti-bot sites).** Cloudflare/DataDome key on datacenter IPs + headless fingerprints, so `web_extract`, the proxyless agent browser, and even a cloud browser often fail - but the **operator's own everyday browser (residential IP, real fingerprint) sails straight through**. For any `blocked` site, hand the operator a paste-ready search URL (built from `search.url_patterns`), give them the identity anchors to judge by (current + prior addresses, age, a distinguishing detail) and the namesake/relative watch-list, and ask for the verdict or a screenshot (the agent can read screenshots). This is a **first-class scan path, not a fallback** - treat the operator's live check as authoritative and record the real verdict (`found` / `not_found` / `indirect_exposure`), citing `scanned_via: operator_browser`. Same for opt-out forms the agent's browser can't reach: guide the operator field-by-field (least-disclosure), pausing before submit. (This is exactly why the same trick clears email-verification links the agent can't open - see the Verification loop.) 4. Capture evidence: save listing URLs and a `browser` screenshot into the subject's `evidence/` dir, then `pdd.py record found --found true --evidence '{"listing_urls":[...]}'`. If a listing genuinely does not exist: `pdd.py record not_found` and move on. ### A 404 (or empty body) is INCONCLUSIVE, not "not_found" A constructed search URL that 404s almost always means the **URL pattern is wrong**, not that the person is absent. Never record `not_found` off a 404. Instead: 1. Re-check the broker's `search.url_patterns` / `url_format_quirks` and rebuild the URL. 2. Fall back to the **on-site search box**: in one `browser_exec` call, `new_tab()` the search page, `fill_input()` the raw query, click Search via `js()`, `wait_for_load()`, then read the **canonical result URL** the site lands on (`js('location.href')`). 3. Only after the site's own search returns an empty result set do you record `not_found`. 4. If a pattern was wrong, fix it in `references/brokers/.json` (`url_patterns` + `url_format_quirks`) so the next run is correct - see the rule below. ### Log URL/format quirks for every site you scrape Whenever you discover how a broker's URLs are actually shaped (path layout, hyphen-vs-slash joins, whether ZIP is required, abbreviation handling, query-param search, anti-bot gating), record it in that broker's `references/brokers/.json` under `search.url_patterns` (the templates) and `search.url_format_quirks` (the gotchas, including which forms 404). Bump `last_verified`. This makes the deterministic URL path reliable across runs and subjects instead of rediscovered each time. If the opt-out form's real requirements differ from the record (extra required fields, a CAPTCHA, an account), fix `optout.requires` / `optout.inputs` / `optout.tier` too - those drive tier selection and least-disclosure. Log opt-out mechanics gotchas (a broker that needs a profile URL but doesn't expose one for the subject, an email-only fallback, an authorized-agent toggle) in `optout.quirks` - the planner surfaces these as `optout_quirks` per broker. Example: Radaris sometimes shows the subject only as a static address-table row with no "View Profile" link, so `/control-privacy` (which needs a profile URL) can't be used - fall back to `optout.email` rather than submitting a namesake's URL. ### Distinguish the subject from namesakes and relatives People-search sites are dense with namesakes and family clusters. Before recording `found`, confirm the record is the **subject themselves** (corroborate via DOB, a known current/prior address, or the identifier you searched). Two non-removable patterns to record as evidence but NOT as the subject's own listing: - **Namesake:** same name, different person (different DOB/location with no overlap). Not the subject. - **Relative record:** the listing is about a *different* person (a relative) and merely *names* the subject in a "Family" field, or carries the subject's email/phone as a secondary datum. This is a third party's record - the consent gate correctly blocks acting on it. See "Indirect exposure" in the web_form section for what the subject *can* still request. Two more false-positive traps that a naive scan records as `found` when it should not: - **Property record != PII (address-anchored sites).** Reverse-address / property sites (rehold, clustrmaps-style) can match on a public **property record** (build year, beds/baths, last sale price, incidents) without exposing the subject's personal info - the resident/owner NAME is behind a "View full report" paywall/signup. Distinguish "this address exists in a public property DB" (non-removable, `not_found`) from "the subject's personal profile is displayed" (removable, `found`). Record `found` ONLY if a resident name matching the subject is publicly shown; an address-only match is `not_found` - there is nothing to opt out of, and public property records are not removable anyway. See `rehold.json` `search.match_signal_notes`. - **SEO-templated title/H1 fakes a "found".** Many people-search sites auto-insert the query into the page ``, H1, and intro copy ("FREE public records found for {Name} in {City}", "Over 100+ FREE public records found for {Name}"). That echo is **templating, not a result** - the actual result cards are often unrelated namesakes in other states. A `match_signal` on title/intro text yields false positives. Require a real result **card** corroborated by the subject's address or DOB, and ignore the templated title/intro/H1 entirely. See `truepeoplesearch.json` / `fastpeoplesearch.json` `search.match_signal_notes`. Both are why the **parent re-verifies every `found` before acting** rule is load-bearing (`pdd.py show <subject> <broker>` reads back a subagent's recorded evidence so the parent can re-verify without re-deriving the listing URL). If a `found` turns out to be a false positive, correct it with a fresh `record ... not_found` carrying an evidence note explaining the retraction. ## web_form 1. `browser_exec`: `new_tab(optout.url)` + `wait_for_load()`; read the form with `page_info()` / `js()` (field names, labels, required flags). 2. Fill only the planned `disclosure_fields` with `fill_input()` (checkboxes/radios via a `js()` click); for `profile_url`, paste the confirmed listing URL from evidence. 3. Submit; `page_info()` to confirm the success state; `capture_screenshot()` into `evidence/`. 4. `pdd.py record <subject> <broker> submitted --disclosed <field> --disclosed <field> --channel web_form`. 5. If the broker requires email verification, follow **Verification loop** below. ### Indirect exposure (named as a relative / your email on someone else's record) You asked the right question: if a broker lists a *relative* and names you in their "Family" field, or shows **your** email/phone on **their** record, that IS personal information about you - even though the record's primary subject is a third party. Resolve it in two distinct lanes: - **The self-service opt-out form does NOT cover this.** That form removes a record whose *primary subject* is you. It has no notion of "scrub my identifiers from this other person's record," and submitting it with the relative's address to force a match would be (a) disclosing data the listing doesn't tie to you and (b) acting on a third party's record. Don't. The consent gate exists to stop exactly that. - **What you CAN do - a targeted "delete my personal information" request (CCPA 1798.105 / GDPR Art.17).** These rights attach to *your* personal information *wherever the business holds it*, including as a data point on another person's profile. So the subject may email the broker's privacy address and request suppression of **their own specific identifiers** (this email address, this phone number, my name in family/relative associations), citing the relative listings as the locations. This is a narrower request than a full opt-out and does not require the relative's consent - you are only asking them to delete data about *you*. Use `render-email` with the `ccpa`/`gdpr` template, list only the subject's own identifiers + the URLs where they appear, and record it as a normal `submitted` → `awaiting_processing` email case. Verify by re-scanning those identifier vectors (email/phone) after the statutory window - `confirmed_removed` only when the subject's identifier no longer appears. - **Caveat:** the broker may decline to alter a third party's record beyond removing your specific identifiers, and "your name in a family graph" can be derived from public records they'll re-list. Note residual exposure in the report rather than marking a clean removal. (Operational guidance, not legal advice.) ## email `pdd.py send-email <subject> <broker> --listing <url> [--kind ccpa|gdpr|ccpa_indirect]` always does the deterministic parts (recipient locked to an address the broker record declares, refusing anything else; `--listing` mandatory; records `submitted`, logs disclosure, stamps `next_recheck_at`). How it actually sends depends on `email_mode`: 1. **browser mode (no password, autonomous):** the command returns a recipient-locked `compose` payload (`to`/`subject`/`body`). Compose a NEW message in the operator's **logged-in webmail** via `browser_exec` (paste `compose.body` exactly, disclosing nothing beyond it) and send. No credentials stored. Requires the inbox signed in in the browser Hermes uses. 2. **programmatic mode (SMTP creds):** the command SMTP-sends it directly, no human. 3. **draft_only fallback:** `pdd.py render-email <subject> <broker> --listing <url>`; a digest entry tells the operator to send it, and the agent records `submitted --channel email` afterward. - **Confirm the contact email with the operator before anything is filed.** Every opt-out form, the registry one-shots, and `send-email` disclose whatever `contact_email_for_optouts` carries, and every confirmation link lands in that inbox. The env default mailbox may be a work address, and a personal run filed to it is a disclosure nobody asked for — ask once at intake; re-filing is the only remedy after the fact. Then follow the **Verification loop** if the broker emails a confirmation link. ## Verification loop (email_verification brokers) - **browser mode (autonomous, no password):** open the broker's confirmation email in the operator's webmail (`browser_exec`), then `pdd.py verify-link <subject> <broker> --text '<email body>'` returns the anti-phishing-scored link. Open it with `browser_exec` (`goto_url(link)`) **in the same browser** (several brokers, e.g. PeopleConnect, bind the session to the browser that opens the link), finish the flow, record `awaiting_processing`. - **programmatic mode (IMAP):** `pdd.py poll-verification <subject>` polls IMAP for every in-flight case, extracts the link (anti-phishing scored: only opt-out-looking links on the broker's own domains), and auto-advances `submitted → verification_pending`. Then open the link with `browser_exec` in the agent's own browser, finish the flow, record `awaiting_processing`. - **draft_only:** the digest tells the operator to click the link in the subject's inbox; the agent records `awaiting_processing` on their word. - Either way, the due queue (`pdd.py due`) brings the case back after the broker's processing window for the verifying re-scan; only that re-scan justifies `confirmed_removed`. ## phone_callback (e.g. Whitepages) Submit the web form, then the site places an automated call with a numeric code. If the operator is available to read the code, capture it and complete the form (T2). Otherwise queue a human task. ## phone (voice menu) / fax / mail / gov_id -> human task (T3) Do **not** attempt to automate. Create a `todo` task and `pdd.py record <subject> <broker> human_task_queued` with exact instructions and an explicit **withhold** list (never SSN; never a driver's-license number unless the subject chooses to and crosses out the ID number). Capture the confirmation reference back into the ledger when the operator completes it. ## captcha **Default: soft/managed CAPTCHAs clear automatically.** The recommended baseline backend is the Browserbase cloud browser (`setup --auto` selects it when `BROWSERBASE_API_KEY` is set). Being a real browser on a residential IP, it passes managed challenges - Cloudflare Turnstile, hCaptcha / reCAPTCHA checkbox - as normal operation, so those brokers stay T1 and you just proceed. This is **not** CAPTCHA solving: no solver service, no fingerprint spoofing. Only a **hard** challenge the browser genuinely can't pass (interactive image grids, behavioral scoring that flags the session) becomes a fallback: `record ... human_task_queued --reason "..."` so it parks as one standing digest task (the operator's own residential browser is the reliable unblock; a `blocked` case would re-scan, re-find the listing and re-queue the opt-out). Without a cloud browser configured, soft-CAPTCHA brokers drop to T2 and become human tasks. **Never use a third-party CAPTCHA-defeating service.** ### CAPTCHA policy, clarified (on a consenting first-party opt-out) - **Do NOT defeat** behavioral / token challenges: a Cloudflare Turnstile that will not auto-clear, **DataDome**, and **"slide-to-verify" gesture-entropy sliders** (the InfoPay lane). These are hard stops -> take the email lane (rule above) or record `human_task_queued` with the reason. - **A visible Google reCAPTCHA v2 / Enterprise checkbox is in this class** (verified live 2026-10-26 across two sites): synthetic CDP clicks on a debug-profile Chrome do NOT toggle it - no token, no challenge appears, no error surfaces, `grecaptcha.getResponse()` stays empty - so it is a silent hard stop for the automation browser. By contrast a managed Cloudflare **Turnstile** auto-cleared on the same residential setup as normal operation. So: Turnstile -> drive the form; reCAPTCHA checkbox -> do not fight it, take the email lane or queue the manual step. - **Acceptable to solve** on the subject's own first-party opt-out: a **static distorted-text image CAPTCHA** (read it with the vision tool) or a **plain arithmetic CAPTCHA** ("8 + 13 = ?"). That is OCR / arithmetic on a consenting removal, not evasion of a bot-detection system. - **But** if the site then rejects the whole submission ("Captcha verification failed / feature not available") after a correct answer, it is fingerprinting the automation itself, not grading the answer -> **stop, do not loop** (e.g. PrivateRecords' distorted-text-THEN-arithmetic double gate). If no cited rights-email exists, that is a genuine `blocked`. ## Spam-call lane (reverse-phone search + DNC registration) A phone-led run ("my number keeps getting spam calls") is the same loop entered from the number: `intake --phone ... --focus-phone ...` (the focus number is what phone-asking opt-out forms disclose), then `next` as usual. `search_vectors` already emits one `by: phone` vector per dossier phone on every broker that declares phone search (14 of the live records; five curated brokers are defunct - dead domains excluded from planning). Three phone-specific notes: - **Reverse-phone pages SEO-echo the number too.** The title/H1 templating trap applies: a real result is a card naming the subscriber (name / age / city), not the query echo. Corroborate against the dossier before recording `found`. - **The page answers "whose number is this".** Running it reveals the subscriber behind the number - only run phone vectors on the consenting subject's own numbers. - **An SSRF-guard refusal can mean the broker is dead, not blocked.** A 'URL targets a private or internal network address' refusal is the fetch guard refusing what DNS actually returns - check the domain against a public resolver before rerunning through a browser: nuwber.com (NXDOMAIN) and clustrmaps.com (public DNS answering 127.0.0.1) both turned out defunct, their 'blocks' being DNS kill-switches. A dead domain is `not_found`, not `blocked`. **DNC one-shot** (`pdd.py dnc <subject>`, surfaced by `next` for US subjects with phones until `--filed`): register on the FTC's National Do Not Call Registry. Free, personal numbers only (business/fax lines are not covered), up to three numbers per registration pass with one confirmation email PER number (open each link within 72 hours or that number is not registered), sales calls stop within 31 days, registration never expires. It stops lawful telemarketers - it does NOT stop scammers, who ignore the list: broker removal is the complementary half, because the people-search listings are where lead lists come from. If the FTC form defeats the configured browser, present it as a manual step in the end-of-run digest; `dnc --filed` records completion so the loop stops re-surfacing it. ## Browser backends: scan vs execute Two different jobs need two different browsers. Getting this wrong is the single biggest cause of a run stalling in Phase 2. - **Phase 1 (scan, read-only):** a cloud stealth browser (Browserbase) or the `scrapling` skill is ideal. On a residential IP with a real fingerprint it passes managed challenges (Cloudflare Turnstile, hCaptcha checkbox) and reads anti-bot people-search pages that `web_extract` and the proxyless agent browser cannot. This is what the skill's `browser_backend` setting governs (`auto` picks Browserbase when `BROWSERBASE_API_KEY` is present - now also read from `$HERMES_HOME/.env`, not just the shell env, so `doctor`/`setup --auto` detect the key Hermes already loads for its own tools). - **Phase 2 (execute: opt-out forms, webmail sends, session-bound multi-step gates):** the work must run in the **operator's own everyday browser** - real fingerprint, residential IP, AND the operator's logged-in sessions. A headless cloud browser is the WRONG default here for two reasons: (1) it is not signed into the operator's webmail, so browser-mode email sends and confirmation-link opens have no inbox to act in; and (2) it is itself Cloudflare/DataDome-gated on exactly the multi-step flows that matter (e.g. PeopleConnect guided-mode, whose verify link is session- and device-bound to the browser that opens it - a cloud browser both fails the challenge and breaks the binding). - **How to drive the operator's browser (CDP).** Point Hermes's browser (`browser_exec`) at the operator's real Chrome over the DevTools protocol: launch `chrome --remote-debugging-port=9222 --user-data-dir="$HOME/.hermes/chrome-debug"` and attach Hermes with `/browser connect` (or `browser.cdp_url` / `BROWSER_CDP_URL`) to `127.0.0.1:9222`. Use a **dedicated debug profile** (`chrome-debug`), NOT the operator's Default Chrome profile, and have the operator sign into their webmail (and any needed broker accounts) in that profile once. That single browser then carries residential IP + real fingerprint + logged-in sessions, which is precisely what Phase-2 flows need. (This is a Hermes-side browser setup, not a `pdd` config value; `browser_backend` above only selects the Phase-1 scan browser.) **The skill launches this for you: `pdd.py cdp`** finds a Chrome/Chromium/Brave/Edge binary, starts it detached on the dedicated profile, waits for the debug port, and prints the CDP endpoint (`webSocketDebuggerUrl`). `pdd.py cdp --check` reports whether a debug browser is already live (and never launches a second one); `pdd.py cdp --print` just emits the exact command for the operator to run themselves. Attach Hermes's browser to the `endpoint` it returns (`/browser connect`). - **Always-available fallback:** if no CDP browser is wired up, use the operator-in-the-loop path (scan ladder 3b) - hand over paste-ready URLs and field-by-field least-disclosure guidance, pausing before submit. It never fails; it just needs a human present. Backend precedence, most to least autonomous: **operator Chrome over CDP** (Phase 2, hands-off once the profile is signed in) > **Browserbase cloud stealth** (Phase 1 scanning, plus managed-captcha forms that need no login) > **proxyless agent browser** (only already-unblocked sites) > **operator-in-the-loop** (paste-ready URLs; the last-resort unblock that always works). ## Ownership clusters - DO PARENTS FIRST (playbooks live in the broker records) Many brokers are resold shells of a few parents, so **one parent removal clears a whole cluster of children** (see `owns` in each record). In Phase 2 you MUST work the cluster **parents first**, then the standalone listings - doing a child before its parent wastes a submission the parent would have covered. `pdd.py plan <subject> --batch` **orders the `found` group parents-first** and emits a `parent_playbook` whose `steps` come verbatim from each record's **`optout.playbook`** - the single source of truth, field-verified, updated as live runs discover mechanics. What follows is the operating doctrine; the exact steps are in `references/brokers/<id>.json`. **Deletion USUALLY beats suppression, email lanes beat forms -- but check the record.** Each parent record carries a structured `optout.deletion` lane (`via: in_flow | email | email_followup`, a privacy address, and `prefer`). The autopilot routes accordingly, and when `deletion.prefer` is false it emits `prefer_suppression` instead of `prefer_deletion`: - **`in_flow`** (PeopleConnect, `prefer: false`): the deletion control lives inside the web flow, but for this cluster it is the WRONG lever for search-visibility (see the exception below). Complete the **suppression** flow and maintain it; do not press Delete unless the goal is a data-purge. - **`via: email`** (Whitepages): the fully-autonomous lane - `send-email` the request (residency-picked kind: CCPA for US-CA, GDPR for EU/UK, generic otherwise), then `poll-verification` for their reply and answer identity questions with least-disclosure. This is also the **rescue lane**: any broker whose form demands a phone-callback/gov-ID/account but that declares a deletion email gets routed here instead of the human digest. - **`email_followup`** (BeenVerified, Spokeo): the opt-out form is the fast primary (it clears the listing), and the playbook then sends a right-to-delete email for full erasure beyond suppression. Verified parent facts (live-checked 2026-07-02; details + steps in the records): - **Intelius/PeopleConnect** (~15+ sites in one flow) -- **EXCEPTION to deletion-beats-suppression.** Portal entry asks only email + consent → verify link is **session-bound to the browser that opens it** → guided-mode. Complete the **SUPPRESSION** flow and keep the account on file: suppression is the do-not-display list that removes you. Per their privacy-center, **'DELETE MY USER DATA' deletes your suppressions and does NOT stop the sites from showing you** (public records re-list), so use it only for a deliberate data-purge. `privacy@peopleconnect.us` is the rights-request address for that path; published metrics: 33.5k deletion requests, median response < 1 day. - **Whitepages**: `privacyrequest@whitepages.com` (or the Zendesk form) handles removal + CCPA deletion **without the phone-callback tool** - that phone call is only required by the automated tool. One removal also drops "all known connected listings". ≤15 days; check 411.com + Premium. - **BeenVerified**: opt-out tool (footer "Do Not Sell" link → `/svc/optout/search/optouts`) + email verification; one opt-out per email address. Then `privacy@beenverified.com` deletion follow-up - controller is The Lifetime Value Co., so name their sister properties (NeighborWho, Ownerly, NumberGuru, Bumper) in the same request, and verify each separately. - **Spokeo**: form takes ONE listing URL at a time and **each listing must be opted out individually** - collect every listing URL from all search vectors first, then submit one opt-out per URL. 24-48h processing. `privacy@spokeo.com` for full deletion beyond free-search suppression. After each parent removal is confirmed, **re-scan its children** before submitting anything for them - usually they drop out and need no separate opt-out. ### Any other parent A parent without a hand-verified `optout.playbook` gets synthesised steps from its structured record (URL/email, `requires` flags, deletion lane, notes/quirks). Follow those, and **write what you learn back into `references/brokers/<id>.json`** (`optout.playbook`, `optout.deletion`, `quirks`, `last_verified`) so the next run is exact - that file, not this one, is where per-broker knowledge accrues.