outreach-prospector-mcp
Queries Greenhouse's public job board API to scan live career postings and discover open roles without requiring paid API keys.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@outreach-prospector-mcpfind the VP of marketing at Stripe and draft a LinkedIn message for approval"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
outreach-prospector-mcp — Zero-Cost Waterfall Enrichment, 6-ATS Scanner & Pre-Send Gate MCP Server
Enterprise B2B & Executive Prospecting without the $500/mo SaaS bloat. A zero-dependency Model Context Protocol (MCP) server combining clean Markdown web scraping, live 6-ATS job board discovery, 4-stage executive waterfall enrichment, and hard pre-send quality gates.
Built by Andrew Anderson (BridgingTheAIGap.com).
Architecture Overview
flowchart TD
A["MCP Client (Claude Desktop / Cursor / Antigravity)"] -->|JSON-RPC 2.0 Stdio| B["outreach-prospector-mcp"]
B --> C["1. scrape_clean_markdown"]
B --> D["2. scan_live_ats_career_ops"]
B --> E["3. waterfall_find_decision_maker"]
B --> F["4. validate_outreach_payload"]
C --> C1["Firecrawl API -> Free Jina Reader -> HTML Fallback"]
D --> D1["Greenhouse + Ashby + Lever + Workable + SmartRecruiters + Recruitee"]
E --> E1["Stage 1: Apollo -> Stage 2: Snov -> Stage 3: Web/LinkedIn Exec -> Stage 4: Hunter"]
F --> F1["Blocks 75+ Generic Aliases, Unreplaced {braces}, & Headline Mismatches"]Related MCP server: LinkedIn Intelligence & Research MCP Server
Key Features
1. Clean Markdown Web & ATS Scraper (scrape_clean_markdown)
Renders JS-heavy Next.js/React career pages, company
/aboutpages, and ATS postings into clean, LLM-ready Markdown.Automatic 3-tier waterfall: Firecrawl API (if
FIRECRAWL_API_KEYset) $\rightarrow$ 100% Free Jina Reader (r.jina.ai) $\rightarrow$ Direct HTML-to-Markdown fallback.
2. Live 6-ATS Public API Scanner (scan_live_ats_career_ops)
Directly queries the public JSON posting APIs of 6 major Applicant Tracking Systems with zero paid API keys required:
Greenhouse (
boards-api.greenhouse.io)Ashby (
api.ashbyhq.com)Lever (
api.lever.co)Workable (
apply.workable.com/api/v3)SmartRecruiters (
api.smartrecruiters.com)Recruitee (
*.recruitee.com/api/offers)
Includes live search discovery to find newly posted roles outside static company slug lists and automatically classifies roles into single-angle tracks (
AI,MARKETING,OPERATIONS).
3. 4-Stage Executive Waterfall Enrichment (waterfall_find_decision_maker)
Stage 1: Apollo.io People Search & Match API (
APOLLO_API_KEY).Stage 2: Snov.io Domain Prospect Search (
SNOV_CLIENT_ID/SNOV_CLIENT_SECRET), automatically rejectinginvalidandnot_verifiedguesses.Stage 3: Web & LinkedIn Named Executive Discovery (
discover_executives_from_web) across/about,/team, and search indexes, chained into Hunter.io / Snov Name-to-Email resolution.Strict Role Hygiene: Automatically excludes board chairmen, non-executive directors, podcast hosts, career coaches, legal counsel, and former employees (
ex-,former).
4. Hard Pre-Send Quality Gates (validate_outreach_payload)
75+ Generic Inbox Blocklist: Blocks
info@,careers@,talent@,support@,dataprotection@,press@,tellmemore@, and leading HTML unicode escape artifacts (u003e).Zero Unreplaced Placeholders: Blocks any outbound payload containing raw
{first_name}or{{company}}braces.Headline-to-Company Verification: Verifies extracted company tokens across all headline separators (
at,@,-,–,|) before sending any LinkedIn DM.Approval-Gated LinkedIn Drafting (
prepare_linkedin_outreach_for_approval): Stages tailored single-angleX -> Y -> Zoutreach drafts inPENDING_APPROVALstate.
Installation
pip install git+https://github.com/andrew4522-cr/outreach-prospector-mcp.gitOr clone locally:
git clone https://github.com/andrew4522-cr/outreach-prospector-mcp.git
cd outreach-prospector-mcp
pip install -e .MCP Client Configuration (Claude Desktop / Cursor / Antigravity)
Add to your mcp_config.json or claude_desktop_config.json:
{
"mcpServers": {
"outreach_prospector": {
"command": "outreach-prospector-mcp",
"env": {
"APOLLO_API_KEY": "optional_apollo_key",
"SNOV_CLIENT_ID": "optional_snov_id",
"SNOV_CLIENT_SECRET": "optional_snov_secret",
"FIRECRAWL_API_KEY": "optional_firecrawl_key"
}
}
}
}Standalone CLI Usage
# 1. Scrape any URL into clean Markdown (zero API keys required)
outreach-prospector-mcp --scrape "https://stripe.com/jobs"
# 2. Scan live Greenhouse, Ashby, Lever, Workable, SmartRecruiters & Recruitee boards
outreach-prospector-mcp --scan-ats
# 3. Run 4-stage waterfall decision-maker discovery for a target company
outreach-prospector-mcp --waterfall "ElevenLabs" "elevenlabs.io"Running Tests
python -m unittest discover -s tests -vLicense
MIT License © 2026 Andrew Anderson
Available Tools
5 toolsprepare_linkedin_outreach_for_approvalC
Finds LinkedIn decision-makers at a target company and drafts approval-gated single-angle LinkedIn outreach messages (OPERATIONS, MARKETING, or AI).
| Name | Required | Description | Default |
|---|---|---|---|
| domain | No | ||
| role_title | Yes | ||
| company_name | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are supplied, so the description carries the full behavioral burden. It does disclose two traits beyond the name: output is approval-gated (drafts, not sends) and each message covers a single angle. It says nothing about whether LinkedIn data is scraped live, what happens on missing domain, whether drafts are persisted, or what the caller receives, all of which matter for a tool with external side effects and compliance risk.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
One sentence, front-loaded with the discovery action and then the drafting action, with no filler. It is efficient and readable; the only weakness is that brevity here comes at the cost of the missing parameter and behavior detail rather than being a deliberate trim.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no annotations, no output schema, and 0% schema description coverage on three parameters, the definition should explain inputs and return shape. Instead it leaves the required role_title undefined and never states what a successful draft response looks like, which is a substantial gap for a multi-step generation tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0% across three parameters, so the description must compensate and does not. 'Target company' loosely maps to company_name, but role_title (a required parameter) and the optional domain are never explained — an agent cannot tell whether role_title is a filter for the decision-maker's title or the sender's, or how domain relates to company_name.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses two concrete verbs with their resources: 'finds LinkedIn decision-makers' and 'drafts approval-gated single-angle LinkedIn outreach messages', and names the angle taxonomy (OPERATIONS, MARKETING, AI). It is clearly distinguishable from a pure lookup like waterfall_find_decision_maker because it produces drafts. It stops short of naming any sibling explicitly, so an agent must infer the boundary itself.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The phrase 'approval-gated' implies the tool stops at a draft and does not send, which is useful workflow context. However, there is no statement of when to choose this over waterfall_find_decision_maker or validate_outreach_payload, no prerequisites, and no indication of what happens after drafting. Usage must be inferred entirely from the name and the word 'approval-gated'.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
scan_live_ats_career_opsC
Multi-ATS live scanner across Greenhouse, Ashby, Lever, Workable, SmartRecruiters, Recruitee, and live ATS search discovery across OPERATIONS, MARKETING, and AI tracks.
| Name | Required | Description | Default |
|---|---|---|---|
| ashby_boards | No | ||
| lever_boards | No | ||
| workable_boards | No | ||
| recruitee_boards | No | ||
| greenhouse_boards | No | ||
| include_live_search | No | ||
| smartrecruiters_boards | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are supplied, so the description carries the full disclosure burden. 'Live scanner' implies real network calls against many boards but the description says nothing about latency, rate limits, per-board failure behavior, result volume, or whether the call is read-only and side-effect free. For a fan-out scraping tool with seven inputs and no safety hints, this leaves significant behavior undocumented.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
It is a single sentence with no filler, but it is a keyword-stuffed fragment rather than a well-structured clause, and the most actionable information (board identifier format, when to use each mode) is absent. Short is good here, but brevity is achieved partly by omitting essentials rather than by tightening.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With seven parameters, no annotations, no output schema, and zero schema descriptions, the description does far too little. An agent still cannot determine what a valid board string looks like, what the response contains, or how the OPERATIONS/MARKETING/AI tracks relate to inputs. Only the platform inventory is adequately covered.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It does partially: the six named ATS platforms map one-to-one onto the six `*_boards` array parameters, letting an agent infer which array feeds which platform. However, it never specifies the expected format of a board entry (slug, subdomain, or full URL), and `include_live_search` is only obliquely referenced via 'live ATS search discovery' without explaining its effect or default.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description names the specific resource and scope: a live job-board scanner covering six named ATS platforms (Greenhouse, Ashby, Lever, Workable, SmartRecruiters, Recruitee) plus live ATS search discovery across OPERATIONS, MARKETING, and AI tracks. An agent can tell this is a multi-source job-posting aggregator. It does not differentiate itself from any sibling, though the listed siblings (markdown scraping, outreach validation) are unrelated enough that confusion risk is low.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no guidance on when to use this tool versus alternatives, no prerequisites, and no statement of what happens when board arrays are omitted. The mention of 'live ATS search discovery' hints at an additional mode but never says when to enable or disable it, or that `include_live_search` defaults to true.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
scrape_clean_markdownA
Firecrawl / Jina Reader clean Markdown web scraper. Renders JS-heavy career pages, Ashby/Greenhouse/Workable boards, and company sites into clean Markdown.
| Name | Required | Description | Default |
|---|---|---|---|
| url | Yes | Website or job posting URL to scrape into Markdown | |
| max_chars | No | Max characters to return (default 8000) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full disclosure burden; it does add real value by revealing that pages are JS-rendered (so dynamic content is captured) and that the output is normalized Markdown. It is silent on rate limits, API keys/auth for the Firecrawl/Jina backends, failure modes for unreachable URLs, and whether output is truncated or paginated.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two tightly packed sentences with zero filler; the capability is front-loaded and the concrete target sites follow immediately as supporting detail.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a low-complexity two-parameter read tool with fully covered schema, the description supplies enough: what it fetches, that it handles JS-rendered content, and what it returns. The only omission is what max_chars truncation means for the caller, which is minor at this complexity level.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so both parameters are already documented, and the description adds no format, syntax, or semantics beyond that. Baseline 3 applies since the schema, not the prose, carries the parameter burden.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource: a web scraper that turns pages into clean Markdown, naming the underlying backends (Firecrawl / Jina Reader). It implicitly separates itself from the sibling set (outreach/decision-maker/ATS-ops tools) by being the fetch-and-convert tool, though it never names a sibling explicitly.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage context is implied through the target list — JS-heavy career pages, Ashby/Greenhouse/Workable boards, company sites — which tells an agent roughly when this is the right tool. There is no explicit 'use this instead of X' routing and no statement of when not to use it, so guidance stops at implication.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
validate_outreach_payloadB
Hard Pre-Send Quality Gate: checks candidate email/DM payloads for generic aliases (info@, careers@), unreplaced template braces ({first_name}), em-dashes, and headline-to-company mismatches.
| Name | Required | Description | Default |
|---|---|---|---|
| body | Yes | ||
| subject | Yes | ||
| headline | No | ||
| company_name | No | ||
| contact_name | No | ||
| recipient_email | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations supplied, the description carries the full behavioral burden. It does disclose the concrete rule set being enforced, which is genuinely useful, but it never says what happens on a violation (throw, return a list, block sending), whether the call is read-only, or whether it mutates the payload.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single front-loaded sentence with the gate label first and the rule list after, with no filler. Dense but readable; it could be split so the outcome of a failed check is surfaced rather than crammed into the rule list.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a 6-parameter validator with no annotations and no output schema, the agent still lacks the result contract: pass/fail shape, list of violations, and whether the caller should abort the send. The input side is reasonably covered by the enumerated rules, but the outcome side is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the schema gives only names and types. The description implicitly maps most inputs to rules — recipient_email via the info@/careers@ check, body/subject via the payload and {first_name} brace check, headline and company_name via the mismatch check. It still does not clarify which params are required, how contact_name relates to the brace check, or accepted formats.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb (checks/validates) and resource (candidate email/DM payloads) and enumerates the exact rules applied: generic aliases, unreplaced braces, em-dashes, headline-to-company mismatches. The 'Hard Pre-Send Quality Gate' framing makes the intent unmistakable, though it never names or contrasts with the sibling prepare_linkedin_outreach_for_approval.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
'Pre-Send' implies the tool is invoked before dispatching outreach, which gives implied timing guidance. However, there is no explicit when-not condition, no statement of what to do with a failing payload, and no named alternative among the siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
waterfall_find_decision_makerC
OpenProspector 4-stage waterfall enrichment (Apollo.io -> Snov.io Domain Search -> Web/LinkedIn Executive Name Lookup + Hunter/Snov Resolver) with strict generic alias filtering.
| Name | Required | Description | Default |
|---|---|---|---|
| domain | Yes | Company domain (e.g. stripe.com) | |
| company_name | Yes | Company name | |
| job_category | No | Role category (executive, marketing, admin-bizdev) | executive |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full disclosure burden and does contribute real behavior: a four-stage provider sequence with explicit fallback order and a 'strict generic alias filtering' rule that signals results exclude info@/sales@ style addresses. It omits what happens on failure (empty result vs. error), whether the waterfall consumes paid API credits or is slow across four providers, and what the returned record looks like.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single sentence with no filler, front-loaded with the tool's identity and then the stage chain. The nested parentheses and arrow notation are dense but every token conveys pipeline information; readability, not verbosity, is the only weakness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a multi-provider enrichment tool with no output schema and no annotations, the description should say what an agent receives (name only, name+title+email, multiple candidates?) and how to interpret a failed waterfall. Those omissions are material for a tool whose whole job is producing a contact record.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so domain, company_name, and job_category are already documented in the schema at baseline 3. The description adds indirect context by naming 'Executive Name Lookup' as a stage, loosely mapping to the job_category default of 'executive', but it never explains how job_category changes the waterfall or which category values map to which providers.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description names the tool as an 'OpenProspector 4-stage waterfall enrichment' and enumerates the providers and fallback chain, so the mechanism is specific. However, it never states the actual outcome (does it return a person's name, an email, a ranked contact list?), so an agent must infer the purpose from the tool name rather than the description.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no statement of when to use this tool, when not to, or which sibling (scrape_clean_markdown, scan_live_ats_career_ops, validate_outreach_payload, prepare_linkedin_outreach_for_approval) it should be preferred over. The only implied usage is 'given a company, find a decision maker,' which is left to inference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
5 tool updates
v1.2.0- First observed
prepare_linkedin_outreach_for_approval - First observed
scan_live_ats_career_ops - First observed
scrape_clean_markdown - First observed
validate_outreach_payload - First observed
waterfall_find_decision_maker
TDQS
Scored across 5 tools
Two overlaps are evident: scrape_clean_markdown explicitly handles ATS/career boards that scan_live_ats_career_ops also targets, and waterfall_find_decision_maker overlaps with prepare_linkedin_outreach_for_approval, which also finds LinkedIn decision-makers. Descriptions clarify intent, but an agent can still misselect when the task is discovery or scraping.
All names use snake_case, but the verb pattern is inconsistent: scrape_clean_markdown and waterfall_find_decision_maker are multi-part or noun-led rather than simple verb_noun. The names remain readable and domain-specific overall.
Five tools is well within the ideal 3-15 range and each maps to a recognizable pipeline stage: scrape, enrich, scan, validate, and prepare. No tool feels redundant enough to remove, and the set is not thin for the apparent scope.
The set covers research, decision-maker discovery, ATS scanning, validation, and LinkedIn outreach preparation, but it lacks email outreach drafting despite validating email payloads, and has no lead/contact storage or status tracking. These are notable gaps for an end-to-end prospecting workflow.
Maintenance
Related MCP Connectors
B2B lead and company intelligence: search leads, enrich contacts, and queue outreach.
B2B lead generation, email verification, company enrichment, and agentic GTM Ops.
Lead enrichment plus AI-written cold emails in one run.
Find scored B2B leads, read campaign replies and send approved LinkedIn outreach.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceEnables B2B prospecting from natural language: detect buying signals, score leads against ICP, enrich decision-makers, and draft personalized outreach messages via Claude.2MIT
- AlicenseBqualityCmaintenanceEnables LinkedIn profile research, post analysis, business signal detection, ICP prospect matching, and sales opportunity discovery through natural language.20119 npmMIT
- AlicenseNot gradedqualityCmaintenanceEnables targeted B2B lead discovery, DNS MX deliverability verification, and extraction of web content into clean Markdown for AI agents.MIT
- AlicenseNot gradedqualityBmaintenanceEnables autonomous B2B lead generation by discovering companies, scraping websites for contacts, decoding obfuscated emails, generating email permutations, and verifying email deliverability via MX and SMTP checks.2MIT