# Scout — Lead Enrichment + OSINT (`logical_vivacity/scout`) Actor

Email finder + lead enrichment + OSINT from public sources. Pass any fragment — name, email, or domain — get a verified dossier: 700+ identity sites, SMTP-validated emails, document mining, sanctions screen, domain→team discovery. $0.05 person, $0.15 domain. No API keys

- **URL**: https://apify.com/logical\_vivacity/scout.md
- **Developed by:** [Logical Vivacity](https://apify.com/logical_vivacity) (community)
- **Categories:** Lead generation, AI, News
- **Stats:** 304 total users, 47 monthly users, 99.8% runs succeeded, 5 bookmarks
- **User rating**: No ratings yet

## Pricing

from $50.00 / 1,000 person enricheds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Scout — OSINT Lead Enrichment, KYC Screening, Domain Intelligence (pay per result)

> **One actor for B2B lead enrichment, KYC / AML screening, vendor due diligence, recruiter sourcing, creator research, and competitive intelligence. Hand Scout an email, name, domain, or handle — pick a strategy that matches your use case — get back a verified, audit-ready dossier with provenance on every fact. No API keys, no per-seat pricing, no subscriptions. You pay only when Scout delivers a result.**

**$0.05 per person · $0.15 per organization · $0.02 per teammate auto-discovered.** Apify compute on top.

Scout is a credential-free OSINT actor that turns any identity fragment — `email`, `full_name`, `domain`, `linkedin_url`, `github_username` — into a structured dossier with sanctions screening, breach exposure, work-email discovery, cross-platform identity correlation across **3,000+ websites**, document mining (PDF / OCR / NER), and (for org strategies) the company's full leadership team enriched as related dossiers in the same run.

***

### Pick a strategy

The single most important input is `strategy`. Scout ships **6 canonical strategies** that cover the common B2B / KYC / OSINT use cases, with sensible defaults for effort, team-spawn behavior, and which enrichment sources fire.

| Strategy | What it's for | Entity | Default effort | Spawns team |
|---|---|---|---|---|
| **`quick_verify`** | "Is this email / handle real?" — fast identity validation | person | 1 | no |
| **`enrich_person`** | Find a person — work email, LinkedIn, employer, GitHub, social posts. Default for sales prospecting and recruiter sourcing. | person | 2 | no |
| **`enrich_org`** | Map an organization — domain + tech stack + sitemap + blog activity + funding events + leadership team. Default for vendor risk, competitive research, and "should I work here." | org | 2 | up to 8 |
| **`compliance`** | KYC / AML — global sanctions + PEP + adverse news + breach exposure. Auto-detects person vs org from input shape. | either | 3 | no |
| **`creator_research`** | Influencer / creator audit — cross-platform audience, post streams, follower counts, recent topics | person | 2 | no |
| **`deep_dive`** | Full online snapshot — every applicable enricher fires (Internet Archive history, ~3,000-site username sweep, Instagram + Twitter + Reddit post streams, dev.to / Medium / Hacker News / Bluesky / Mastodon / Keybase, OpenAlex + arXiv, breach + sanctions, EXIF avatar mining, typosquat detection on personal domain). Slowest + most thorough. | either | 3 | up to 5 |

#### Legacy aliases (still accepted)

The actor previously shipped 11 strategies. The five organization-specific names plus `prospecting` / `recruiter` / `due_diligence` / `org_compliance` continue to work — they resolve to one of the canonical six with a small tag overlay so existing customer integrations don't break.

| Legacy name | Resolves to | Overlay |
|---|---|---|
| `prospecting` | `enrich_person` | (no change) |
| `recruiter` | `enrich_person` | + academic / documents tags |
| `due_diligence` | `enrich_person` | + compliance / academic / documents, default effort 3 |
| `vendor_dd` | `enrich_org` | + compliance / phishing tags, default effort 3, spawn cap 5 |
| `competitive_research` | `enrich_org` | spawn cap 10 |
| `hiring_target` | `enrich_org` | spawn cap 5 |
| `org_compliance` | `compliance` | (no change — `compliance` auto-detects entity kind) |

New integrations should use the canonical names; legacy aliases will continue to work for the foreseeable future.

#### Try it in 30 seconds

```jsonc
// B2B prospecting / recruiter sourcing on a person
{ "strategy": "enrich_person", "full_name": "Jane Doe", "company_name": "Acme Inc" }

// KYC / AML screen — auto-detects person vs org from the input
{ "strategy": "compliance", "full_name": "Jane Doe", "email": "jane@acme.com" }
{ "strategy": "compliance", "domain": "acme.com" }

// Map an organization (vendor risk / competitive research / "should I work here")
{ "strategy": "enrich_org", "domain": "acme.com" }

// Full online snapshot of a person — every applicable source
{ "strategy": "deep_dive", "full_name": "Jane Doe", "email": "jane@acme.com" }
```

The `effort` dial (1-3) modulates depth within a strategy: `1` is fast verify-only, `2` is the standard run, `3` is thorough (more candidate sources, bigger team-spawn cap, OCR on documents). Per-result billing is identical at every effort level.

#### Advanced: pass-count override

Each strategy ships with a default number of orchestration **passes** (1 for `quick_verify`, 2 for most, 3 for `deep_dive`). A pass = one full sweep of every eligible enricher. Late-arriving evidence in pass N can unlock new enrichers in pass N+1 (e.g. a homepage scrape reveals a GitHub URL → next pass runs the GitHub stack).

Override with the optional `passes` input (range 1-4):

```jsonc
// Re-check a known-good seed cheaply
{ "strategy": "enrich_person", "email": "jane@acme.com", "passes": 1 }

// Chase deeply-chained evidence on a hard case
{ "strategy": "deep_dive", "email": "jane@acme.com", "passes": 4 }
```

The orchestrator stops early when no new evidence arrives between passes, so raising the cap rarely wastes work — most runs converge in 2 passes regardless.

***

### What Scout returns

Each input becomes one or more dataset records. The **primary dossier** carries every populated `Field` with a typed `verdict` (best-guess value with confidence + sources) plus the full `evidences` chain so every fact is traceable. **Spawned related dossiers** (teammates discovered via team-page scraping or GitHub org membership) land as separate dataset records.

#### Identity (every strategy)

- **Name parsing** — `full_name` → first / last + name-commonness rating (rare / common / very\_common, region-aware via global names dataset across 150 countries) so disambiguation strictness scales with name ambiguity
- **Email validation** — syntax + MX record + breach lookup (Have I Been Pwned)
- **Phone normalization** — any format → E.164
- **Personal-domain detection** — auto-probes `<first><last>.{com,io,co,me,…}` against the lead's name

#### Email-keyed enrichment

- **Gravatar profile lookup** by email-MD5 hash
- **Account footprint scan** across **120+ services** (account-existence probing via password-reset endpoints)
- **Recovery email + phone hints** — Adobe / Samsung / mail.ru / Odnoklassniki sometimes leak partially-redacted recovery identifiers in their password-reset response, fed back into the dossier
- **Email pattern detection** — when the lead's email matches a known shape, infer the employer's pattern (`first.last`, `flast`, `firstl`, …) for downstream prospecting
- **SMTP RCPT verification** with explicit catch-all domain detection

#### Cross-platform identity

- **3,000+ sites** probed via cross-platform username lookup. Surfaces GitHub, LinkedIn, Twitter/X, Bluesky, Mastodon, Reddit, Stack Overflow, Medium, dev.to, Hacker News, Wikipedia, Patreon, Substack, Twitch, Steam, Spotify, Behance, Dribbble, DeviantArt, Goodreads, Letterboxd, Strava, Chess.com, Vivino, Etsy, Trello, Foursquare, Flickr, Imgur, Wattpad, Pinterest, TikTok, Instagram (where public), Snapchat, Tumblr, and many more
- **Keybase profile** — cryptographically-verified cross-platform proofs
- **Schema.org structured-data extraction** from any profile page found
- **Known-handle disambiguation** — when multiple matches surface, the GitHub `name` field cross-checks against the lead's name to demote impostors

#### GitHub depth (enrich\_person at effort 2-3)

- Profile, top languages, follower count, public\_repos
- Recent activity timeline + commit cadence + timezone inference
- Top repos with stars / topics / language
- Email harvest from public commits
- Package ownership across npm / PyPI / RubyGems / crates.io / Docker Hub

#### Compliance (compliance strategy + deep\_dive)

- **Global sanctions + PEP screening** across UN / EU / UK / Switzerland / US OFAC sanctions + PEP lists + crime / terror / corruption — ~600,000 consolidated entities
- **Token-overlap sanity check** kills hash-collision false positives so a name like "Anmol Sharma" doesn't match against unrelated entities
- **Adverse news scan** with anchor-coherent snippet filtering — drops hits that name a different identifier than the primary anchors
- **Breach report** for the email's domain via public breach-aggregation service
- **Held-back candidates** — surfaces same-name profiles Scout *considered* but didn't promote, with the distinguishing attributes that disqualified them. Transparent disambiguation, not silent filtering.

#### Academic (enrich\_person at effort 3, deep\_dive)

- **Author + works + citation graph** — ~250M papers, ~250M authors, ORCID-aware disambiguation
- **Preprint search** by author across the major preprint servers
- Top-cited works, affiliations, h-index proxies

#### Document mining

- Open-web search across 12 fallback engines (Brave, Google, Yandex, Startpage, Yep, DuckDuckGo, Bing, Ecosia, Yahoo, Mojeek, Qwant, SearXNG) with TLS-fingerprint impersonation
- **PDF + DOCX extraction** with table-aware text recovery → emails / phones / URLs / employers / skills / education
- **Named-entity co-occurrence** finds people, companies, locations mentioned alongside the lead with proximity scoring
- **Resume parsing** — section-aware → structured `WorkExperience` and `EducationEntry`
- **Image mining** with EXIF, alt-text, OCR

#### Domain enrichment (org strategies)

- **WHOIS + DNS** (A / AAAA / MX / NS / TXT) + IP geolocation + ASN
- **MX provider detection** (Google Workspace / Microsoft 365 / ProtonMail / Zoho / Fastmail / SES / Mailgun / SendGrid)
- **CDN + tech-stack fingerprinting** with a 3,000-pattern technology database
- **Subdomain enumeration** via certificate transparency logs
- **Phishing / typosquat detection** via domain-permutation + DNS resolution
- **Sitemap categorization** — `/sitemap.xml` URLs bucketed by intent (pricing, products, blog/news, customers / case studies, careers, docs, legal) so the customer sees product-shape signal, not a raw URL list
- **Well-known endpoints + favicon hash + WordPress REST user enum** (when the org runs WP)
- **JSON-LD projection** — `Schema.org/Organization` blocks parsed and projected onto first-class slots: `description` (one-line "what they do"), `location` (HQ from `address` / `contactPoint.areaServed`), `profiles` (each `sameAs` URL becomes a service-tagged profile entry — LinkedIn, Twitter, GitHub org, Crunchbase, Facebook), inline `Person` schemas spawn related teammate dossiers with `jobTitle`
- **Apify Proxy honoured everywhere** — no upstream source bypasses your residential proxy

#### Hiring signals (enrich\_org)

- **ATS detection** — Greenhouse / Lever / Ashby / Workable APIs probed for open roles + departments
- **Team-page extraction** — fetches team / about / leadership pages with a real browser, extracts names + titles via named-entity recognition, **spawns one Person dossier per teammate** which gets the full enrichment pipeline (work-email finder targeted at the company domain, GitHub, social profiles, sanctions, …)
- **Title extraction from snippets** — match across all collected dork hits catch role titles (CEO / CTO / Chief Technology Officer / VP / Head of …) even when never listed on a team page
- **Internet Archive history** — historical snapshots of pages that auth-wall today
- **Crunchbase / Glassdoor / BuiltWith / Product Hunt / OSS-repo signals**

#### Press, funding & company timeline (org strategies)

- **Funding events** — news-targeted dorks (`<org> raised | "series a" | seed | funding`) surface investment announcements; named-entity recognition pulls money amounts + funding-keyword proximity extracts the figure (`$200K`, `$5M Series A`)
- **Launch / acquisition / partnership detection** — headline patterns (`launched`, `acquired`, `partners with`, `appoints`) classify each press hit into an event kind (`funding` / `acquisition` / `launch` / `partnership` / `hiring`)
- **Founding date inference** — `founded` / `since` / `established` keyword anchors + date entity recognition → org's founding year
- **Headcount inference** — regex matches on `team of N`, `N+ employees`, `N-person team` patterns across the snippet corpus
- **HQ / location inference** — top geopolitical entity (city / country) by frequency across all dork hits, useful when the org doesn't publish an address

#### Creator-economy signals (creator\_research)

- **Twitter / X post stream** (recent posts + engagement)
- **Reddit post + comment history**
- **Instagram public profile** (followers, post count, business-account flag, external URL)
- **YouTube + TikTok + Twitch + Patreon** profile detection via username pivot

#### Quality + transparency

- **Lead score** (0-100) with persona classification (developer / executive / academic / creator)
- **Identity-locked flag** — true when ≥2 of {email, full\_name, github, linkedin} clear the verdict threshold
- **Per-field confidence map** + per-field source list
- **Coherence filter** — discoveries whose context bag contradicts primary anchors get demoted to `candidates` with a clear reason (rather than silently merged or dropped)

***

### Output shape

Each dataset record holds a primary dossier + run metadata + (optionally) markdown:

```jsonc
{
  "primary": {
    "id": "lead-1",
    "kind": "person",                 // or "organization"
    "full_name": {
      "verdict":   { "value": "Jane Doe", "confidence": 0.95, "sources": ["github_profile","gravatar","input"] },
      "evidences": [ /* full chain with source, timestamp, derived_from, … */ ]
    },
    "email":      { "verdict": [ /* multi-card */ ], "evidences": [ /* … */ ] },
    "linkedin_url": { "verdict": { /* … */ }, "evidences": [ /* … */ ] },
    "title":      { "verdict": { "value": "CTO", "sources": ["snippet_extract"] }, "evidences": [ /* … */ ] },
    "location":   { "verdict": { "value": "Waterloo", "sources": ["snippet_extract","page_meta"] }, "evidences": [ /* … */ ] },
    "handles":    { "verdict": [ /* … */ ], "evidences": [ /* … */ ] },
    "profiles":   { "verdict": [ /* … */ ], "evidences": [ /* … */ ] },
    "documents":  { "verdict": [ /* … */ ], "evidences": [ /* … */ ] },
    "sanctions":  { /* … */ },
    "adverse_news": { /* … */ },
    "account_footprint": { /* … */ },
    // Org-only slots (kind=="organization")
    "description":{ "verdict": { "value": "Voice AI for home services …", "sources": ["page_meta","homepage"] } },
    "founded":    { "verdict": { "value": "2023", "sources": ["snippet_extract"] } },
    "headcount":  { "verdict": { "value": "50", "sources": ["snippet_extract"] } },
    "events":     { "verdict": [ { "value": { "kind": "funding", "amount": "$200K", "url": "…" } } ], "evidences": [ /* … */ ] },
    "tech_stack": { "verdict": [ /* multi-card */ ] },
    "candidates": { /* held-back same-name profiles */ },
    "related":    [ /* recursively-shaped child dossiers — spawned teammates */ ]
  },
  "quality": {
    "score": 72, "tier": "hot", "persona": "developer",
    "identity_locked": true, "evidence_strength": "verified",
    "confidence": 0.85, "rationale": ["identity locked: 4/4 core fields ≥0.7"]
  },
  "_meta": {
    "kind": "person", "record_kind": "primary", "strategy": "enrich_person"
  }
}
```

Set `outputFormat: "md"` to get a clean markdown rendering instead — drop directly into a Claude / GPT prompt for outreach copy, qualification, summarization. Set `outputFormat: "both"` to keep both.

The Apify dashboard ships **5 pre-built table views**: Overview (default), Compliance, Organization, Social presence, Provenance — filter by strategy, kind, score tier, or identity\_locked without writing a transformation.

***

### Pricing

Pay-per-event Apify monetization. No monthly fee, no per-seat license, no API keys.

| Event | Fires when | Price |
|---|---|---|
| `person_enriched` | A person dossier completes (primary or seeded-from-email) | **$0.05** |
| `domain_enriched` | An organization / domain dossier completes | **$0.15** |
| `team_member_spawned` | A teammate found via org → team discovery and enriched | **$0.02** each |
| `apify-actor-start` | Fixed start fee | **$0.00005** |

Typical runs:

- `enrich_person` on a person → **$0.05**
- `compliance` on a person (sanctions + adverse news + breach) → **$0.05**
- `enrich_org` on a domain returning 5 enriched leadership teammates → **$0.15 + 5 × $0.02 = $0.25**
- `enrich_org` on a domain returning 8 teammates → **$0.15 + 8 × $0.02 = $0.31**
- 1,000 cold leads at `enrich_person` strategy, ~70% identity-lock rate → **~$35 + Apify compute**

Apify compute fees are billed separately by Apify based on memory + duration — typically a few cents per run.

***

### How Scout compares

|   | **Scout** | Apollo / ZoomInfo / Clearbit | Hunter.io | OSINT Industries | SpiderFoot HX |
|---|---|---|---|---|---|
| **Pricing** | Pay-per-result (5¢–15¢) | $1K–$30K+ / yr per seat | $50–$500+ / mo | Subscription | $99+ / mo |
| **API keys / minimums** | None | Yes | Yes | Yes | Self-hosted only |
| **Data source** | Public web with per-fact provenance | Proprietary database | Email guesses | Public + private mix | Public + paid feeds |
| **Sanctions / KYC / AML** | ✅ Global sanctions + PEP + OFAC | Add-on | No | Yes | Yes |
| **Email finder + SMTP verify** | ✅ With catch-all detection | Database | ✅ | No | No |
| **Domain → team people** | ✅ Spawn each + enrich in same run | Database | No | No | Limited |
| **Cross-platform identity (3000+ sites)** | ✅ | None | No | Limited | Yes |
| **Resume / PDF / OCR mining** | ✅ Table-aware + named-entity extraction | Limited | No | No | Limited |
| **GitHub depth** | ✅ Profile, repos, packages, commits | None | No | Limited | Limited |
| **Academic papers / citations** | ✅ ~250M papers, ORCID-aware | No | No | No | No |
| **Adverse media** | ✅ Anchor-coherent filtering | Add-on | No | Yes | Yes |
| **Tech stack detection** | ✅ 3000-pattern fingerprinting | Limited | No | No | Yes |
| **Phishing / typosquat detection** | ✅ | No | No | No | Yes |
| **Auditable provenance per fact** | ✅ Full evidence chain | No | No | Mixed | Mixed |
| **Self-hostable** | ✅ Run on your own Apify account | No | No | No | Yes |

Scout isn't a 200M-row contact database. It's a **verifiable, one-shot dossier per lead, paid by the result**, with provenance your compliance team can audit.

***

### Use cases (with strategy mapping)

#### B2B Lead Enrichment for Sales Prospecting (Apollo / Clearbit Alternative) — `enrich_person`

Turn a sparse CRM record into a complete contact dossier. Pass `full_name` + `company_name` and Scout finds the work email via SMTP verification with catch-all detection, the LinkedIn URL, GitHub presence, social profiles, and the lead's role. Pay-per-lead pricing instead of per-seat licenses.

#### Sales Intelligence at the Organization Level (ZoomInfo Alternative) — `enrich_org`

Pass a domain, get the leadership team. Scout walks team / about / leadership pages, extracts names + titles via named-entity recognition, spawns a Person dossier per teammate, and enriches each — outreach-ready in one run. One billable input → org dossier + N enriched team members.

#### KYC / AML Compliance Screening (OFAC + PEP + Sanctions) — `compliance`

Sanctions screen against a global consolidated dataset (UN / EU / UK / Switzerland / OFAC / PEP — ~600K entities), adverse-media scan with anchor-coherent filtering (drops false positives that name a different identifier), breach exposure check. Auto-detects person vs organization from the input — `email`/`name` → person, bare `domain` → org. Compliance-ready output with full provenance for every flag.

#### Vendor Due Diligence & Procurement Risk Assessment — `enrich_org` (or legacy `vendor_dd`)

Procurement risk scan on a vendor: WHOIS history + tech stack + ATS hiring activity + sanctions on the org + leadership team enriched + phishing-domain detection. The legacy `vendor_dd` alias adds compliance + phishing tags and bumps default effort to 3; the canonical `enrich_org` at effort 3 plus a separate `compliance` run gives the same coverage with explicit provenance.

#### Recruiter Sourcing & Candidate Research (Hired / SourceWhale Alternative) — `enrich_person` (or legacy `recruiter`)

Enrich a candidate's full public footprint: GitHub depth (repos, languages, commit cadence), Stack Overflow reputation, package ownership across npm / PyPI / RubyGems / crates.io, academic papers + citations + co-authors, structured employment history mined from PDF resumes. The legacy `recruiter` alias adds academic + documents tags on top of the base `enrich_person` set.

#### Investment Due Diligence on People (Background Check Alternative) — `enrich_person` at effort 3 (or `deep_dive`)

Person-level DD: identity verification + compliance + academic record + professional history + cross-platform consistency check. Surfaces inconsistencies (different email in public records vs. CV vs. LinkedIn) as held-back candidates rather than silently merging. The legacy `due_diligence` alias is `enrich_person` + compliance / academic / documents at effort 3.

#### Influencer & Creator Research / Sponsorship Vetting — `creator_research`

Cross-platform audience audit: Twitter/X post stream + Reddit history + Instagram metrics + YouTube/TikTok/Twitch detection. Useful for sponsorship matching, brand-fit qualification, audience-overlap analysis, fake-follower screening.

#### Competitive Intelligence & Competitor Mapping — `enrich_org` (or legacy `competitive_research`)

Map a competitor's footprint: tech-stack fingerprinting, hiring signals from major ATS platforms (Greenhouse / Lever / Ashby / Workable), GitHub org activity, open-source repo detection, leadership team mapping, Internet Archive timeline of their site, blog activity heartbeat, recent funding / launch / acquisition events.

#### Pre-Offer Company Research ("Should I Work Here?") — `enrich_org` (or legacy `hiring_target`)

Check an org before accepting an offer: Glassdoor + Crunchbase signals, hiring momentum (ATS open roles + departments), tech stack, leadership profiles, OSS commitment, growth trajectory.

#### CRM Hygiene, Dedup & Cold-List Scoring

Re-enrich existing leads, surface stale records, dedupe via cross-source identity verification + the coherence filter. Run at `quick_verify` strategy for ~10s/lead cold-list scoring before targeting outreach.

#### OSINT, Investigative Journalism & Background Research

Public-source person lookup with per-field provenance. Cross-platform identity correlation surfaces aliases. Document mining on web-search results pulls structured evidence from PDFs. Audit-ready output for editorial standards.

***

### FAQ

**How do I find someone's work email from just their name?**
Pass `strategy: "enrich_person"` with `full_name` + `company_name` (or `domain`). Scout runs domain enrichment, generates plausible work-email patterns (`first.last`, `flast`, `firstl`, `f.last`, `first`, …), runs SMTP RCPT against each candidate, and returns the first verified hit with full provenance. Catch-all domains are detected explicitly and flagged so you don't act on false positives.

**What sanctions / PEP coverage do I get?**
The `compliance` strategy screens against a consolidated global dataset of ~600,000 sanctioned / PEP / criminal-listed entities aggregated from UN, EU, UK, Switzerland, US OFAC, PEP databases, and crime / terror / corruption lists. Token-overlap sanity discards hash-collision false positives so a name like "Anmol Sharma" doesn't get matched against "SHAZAND PETROCHEMICAL COMPANY." Auto-detects person vs organization from the input shape.

**How does the org → team flow work?**
At the `enrich_org` strategy, Scout enriches the domain (WHOIS / DNS / hosting / tech-stack fingerprinting / certificate transparency / sitemap) AND fetches the team / about / leadership pages with a real browser so JavaScript-rendered content lands in the DOM. Named-entity extraction surfaces names with strict validity filtering (rejecting marketing copy and section headings), pairs each detected name with the title text immediately following it, and spawns one Person dossier per teammate. Each spawned person is enriched concurrently with the primary's later tiers — so a single domain input returns the org + N enriched team members in roughly the same wall-clock time as enriching just the org.

**How does pay-per-event billing work?**
Apify's pay-per-event meter ticks once per dataset record pushed. Each primary dossier fires `person_enriched` ($0.05) or `domain_enriched` ($0.15) depending on `_meta.kind`. Each spawned related dossier fires `team_member_spawned` ($0.02). If Scout doesn't push a primary record (e.g., input was empty or the actor crashed before completion), nothing bills.

**Can I run on a list of 10,000 leads?**
Yes — invoke the actor once per lead via the Apify API. Apify scales horizontally. Budget ~30s per person at `prospecting` effort=2, ~90s per domain at `vendor_dd` effort=3 (with team spawn). Run cold-list scoring at `quick_verify` (~10s) to keep wall time tight; bump to higher strategies for the leads that actually convert.

**Why don't I see LinkedIn personal-profile content even though the URL is in the output?**
LinkedIn aggressively gates personal profiles. Scout records the URL it found but won't fake the content if LinkedIn returns 999. Company pages frequently come through; personal pages typically don't, and we tell you that openly rather than emit dead fields.

**Does Scout work for non-English names?**
Yes. The `commonness` enricher is region-aware (backed by a global names dataset across 150 countries), so `Anmol Sharma` is correctly scored as common-in-India rather than rare-globally. Romanized names work best; CJK names work but disambiguation is harder when the input is name-only.

**Will I be charged for a thin run?**
The `quality` block on every record includes a `tier` field. If you only want to bill on identity-locked outputs, filter the dataset by `quality.identity_locked = true` before downstream processing — Apify's pay-per-event meter has already counted the record either way (we publish what we find), but your downstream code can ignore thin records.

**How is Scout different from a 200M-row contact database?**
Apollo / ZoomInfo / Clearbit ship a database snapshot — you query their data. Scout ships a researcher — you give it a clue, it goes to the public web and brings back a dossier with proof. Different shape, different price model. Scout is best when you need *current*, *verifiable*, *low-volume* enrichment with provenance. The big DBs are still better when you need 50K records overnight and don't care about audit trail.

**Can I see the output before paying?**
Yes — Scout is free to install on Apify and you only pay when the per-event billing fires. Run it on a single lead from your CRM at `quick_verify` strategy to evaluate the output shape and quality before scaling up.

***

### Limitations

- **Anti-bot variability.** LinkedIn personal profiles, Glassdoor company pages, Crunchbase profile bodies, and a handful of aggressive anti-bot sites still 999 / 403 even with stealth + proxy. Scout records what it tried and never falsifies the result.
- **Identity ambiguity on common names.** A common first + last name combination with no email, handle, or domain is hard to disambiguate. Scout's `commonness` enricher flags the risk and the coherence filter requires multi-anchor corroboration before promoting a candidate to a primary identity field.
- **SMTP RCPT is unreliable in production.** Many providers accept-all or block from cloud IPs. A successful SMTP RCPT means "the receiving server didn't reject" — not "this address truly works." Scout detects catch-all domains explicitly and downgrades the confidence on those hits with a warning in the evidence chain.
- **NER false positives on team pages.** Entity extractors occasionally tag marketing copy as PERSON. Scout's post-extraction filter (regex blocklists + names-dataset surname validation) catches the vast majority; rare edge cases may slip through.
- **Public data only.** No customer-supplied API keys, no paid data brokers, no auth-walled content.

Scout never raises on a single source failure — you always get a result, with the gaps clearly marked.

***

### Use responsibly

The output describes real people and organizations. Your jurisdiction may regulate how this kind of data can be stored, redistributed, or sold (GDPR, CCPA, PIPEDA, state data-broker statutes, etc.). Scout is a research tool — operating it for due diligence, sales research, recruiting, or investigative work on parties with whom you have a legitimate interest is what it's built for. Bulk dataset construction or resale without lawful basis is on you.

Scout never bypasses authentication, never solves CAPTCHAs, and never exceeds public rate-limit guidance. If a source returns "auth required" or rate-limits the request, the corresponding field is left null and the failure is recorded in the evidence chain.

***

### Run it now

[Run Scout on Apify →](https://apify.com/) · Free to install, pay only per delivered result. No subscription, no API keys, no minimums.

**Tags:** lead enrichment · OSINT · email verification · SMTP verifier · sanctions screening · KYC · AML · OFAC · PEP screening · adverse media · domain intelligence · company enrichment · firmographics · tech stack detection · cross-platform identity · person lookup · contact finder · LinkedIn enrichment · GitHub OSINT · academic papers · citation graph · resume parsing · PDF mining · OCR · breach exposure · vendor due diligence · competitive intelligence · recruiter sourcing · creator research · pay per result · Apollo alternative · Clearbit alternative · Hunter.io alternative · ZoomInfo alternative · OSINT Industries alternative · SpiderFoot alternative

# Actor input Schema

## `strategy` (type: `string`):

What you're trying to accomplish. Six canonical strategies cover the common use cases; legacy names (prospecting, recruiter, vendor\_dd, competitive\_research, hiring\_target, due\_diligence, org\_compliance) still work as aliases that map to a canonical strategy with the right overlay.

## `effort` (type: `integer`):

Quality vs. speed dial within the strategy. 1=fast (~30s, identity-first), 2=standard (~120s, full enrichment), 3=thorough (~200s, expensive sources + bigger team-spawn cap). Per-record billing is identical at every level.

## `passes` (type: `integer`):

Override the strategy's default pass count. A pass = one full sweep of every eligible enricher. Late-arriving evidence in pass N can unlock new enrichers in pass N+1 (e.g. a homepage scrape reveals a GitHub URL → next pass runs the GitHub stack). Most runs converge in 2; raise to 3-4 only when chasing deeply chained evidence. Leave blank to use the strategy default (quick\_verify=1, most=2, deep\_dive=3).

## `outputFormat` (type: `string`):

How the dossier is shaped in the dataset record. `json` returns the structured Dossier (per-field verdict + evidences). `md` returns a human-readable markdown dossier under `markdown` — drop directly into an LLM prompt without parsing JSON. `both` includes both fields. Pick `md` when feeding Scout's output into AI agents (Claude, GPT) for synthesis / outreach copy / qualification.

## `full_name` (type: `string`):

Person's full name. Single most useful anchor on its own.

## `email` (type: `string`):

Email address. Auto-validated, breach-checked, MX + SMTP verified.

## `phone` (type: `string`):

Phone number in any format — auto-normalised to E.164.

## `first_name` (type: `string`):

Optional split — supply if you only have parts.

## `last_name` (type: `string`):

Optional split — supply if you only have parts.

## `title` (type: `string`):

The person's title or role.

## `location` (type: `string`):

City, state, country — used for disambiguation.

## `linkedin_url` (type: `string`):

Person's LinkedIn profile URL.

## `github_username` (type: `string`):

GitHub handle (with or without leading @).

## `twitter_handle` (type: `string`):

X (Twitter) handle.

## `company_name` (type: `string`):

Person's employer (or, for org strategies, the organization name).

## `domain` (type: `string`):

Company website domain. For org strategies (vendor\_dd / competitive\_research / org\_compliance / hiring\_target), this is the primary anchor.

## `proxyConfiguration` (type: `object`):

Apify Proxy is strongly recommended — several upstream sources rate-limit single IPs.

## Actor input object example

```json
{
  "strategy": "enrich_person",
  "effort": 2,
  "outputFormat": "json",
  "full_name": "Jane Doe",
  "email": "jane@acme.com",
  "phone": "+1 (415) 555-1234",
  "title": "Head of Engineering",
  "linkedin_url": "https://www.linkedin.com/in/jane-doe",
  "github_username": "janedoe",
  "company_name": "Acme Inc",
  "domain": "acme.com",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `results` (type: `string`):

All enriched dossiers from this run — the primary lead plus any spawned related teammates. Each row is one billable record (`person_enriched` $0.05 / `domain_enriched` $0.15 / `team_member_spawned` $0.02). Filter by `_meta.record_kind` to scope to primaries or related, or by `_meta.kind` to scope by entity kind.

## `overview` (type: `string`):

Top-line columns per dossier: name, email, phone, location, LinkedIn, domain, score, tier, persona, identity\_locked. The default Apify Console view for spreadsheet-style scanning of a list run.

## `compliance` (type: `string`):

Sanctions hits, adverse-news matches, and breach exposure per dossier. Filter to non-empty rows for KYC / AML reporting.

## `company` (type: `string`):

Firmographic columns for org dossiers — industry, headcount, founded, tech stack, hiring activity. Filter `_meta.kind = organization` for org-only rows.

## `social` (type: `string`):

Cross-platform handle + profile coverage per dossier — surfaces the lead's GitHub / LinkedIn / Twitter / Reddit / Mastodon / 3000+-site footprint.

## `provenance` (type: `string`):

Per-field evidence chain — every value with the source(s) that supplied it, when, and the chain of derivation. The audit trail your compliance team can inspect to answer 'where did this come from?' for any datum.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("logical_vivacity/scout").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "proxyConfiguration": { "useApifyProxy": True } }

# Run the Actor and wait for it to finish
run = client.actor("logical_vivacity/scout").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call logical_vivacity/scout --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,logical_vivacity/scout"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/QibXpKy8UgrlzUMdO/builds/bMZN2qMk3JfybTQwR/openapi.json