Apollo.io MCP Server

Use Apollo.io CRM from Claude Desktop, n8n, or any MCP-compatible client. Search contacts, enrich leads, manage sequences, deals, and tasks — all through natural language or automated workflows.

Built with FastMCP, httpx, and Python 3.11+.

Features

20 tools covering the full Apollo.io API: contacts, enrichment, organizations, sequences, tasks, and deals
Async HTTP client with built-in error handling (rate limits, auth errors, validation)
Zero config: just add your API key and connect
Works with Claude Desktop, Claude Code, n8n, and any MCP client

Quick Start

1. Get your Apollo API Key

Go to Apollo Settings → Integrations → API Keys and create a new key.

Important: Toggle "Set as master key" if you want access to all endpoints (sequences, tasks, deals, get contact/organization by ID).

2. Clone the repo

git clone https://github.com/aisacAdmin/apollo-mcp.git
cd apollo-mcp

3. Configure your API key

cp .env.example .env
# Edit .env and paste your Apollo API key

4. Run the server

With uv (recommended):

uv run --with fastmcp --with httpx --with python-dotenv fastmcp run main.py

With pip:

pip install fastmcp httpx python-dotenv
python main.py

Connect to Claude Desktop

Add this to your claude_desktop_config.json:

macOS: ~/Library/Application Support/Claude/claude_desktop_config.json Windows: %APPDATA%\Claude\claude_desktop_config.json

With uv (recommended)

{
  "mcpServers": {
    "apollo": {
      "command": "uv",
      "args": [
        "run",
        "--with", "fastmcp",
        "--with", "httpx",
        "--with", "python-dotenv",
        "fastmcp", "run",
        "/absolute/path/to/apollo-mcp/main.py"
      ],
      "env": {
        "APOLLO_API_KEY": "your_api_key_here"
      }
    }
  }
}

With Python directly

{
  "mcpServers": {
    "apollo": {
      "command": "python3",
      "args": ["/absolute/path/to/apollo-mcp/main.py"],
      "env": {
        "APOLLO_API_KEY": "your_api_key_here"
      }
    }
  }
}

Restart Claude Desktop after saving. You should see the Apollo tools available in the tools menu.

Available Tools (20)

Contacts

| Tool | Description | |------|-------------| | search_contacts | Search contacts with keywords, filters, and pagination | | get_contact | Get a single contact by ID | | create_contact | Create a new contact (first name, last name, email, company, title) | | update_contact | Update an existing contact's fields | | delete_contact | Delete a contact by ID | | bulk_create_contacts | Bulk create up to 100 contacts at once |

People Enrichment

| Tool | Description | |------|-------------| | enrich_person | Enrich a person by email, name+company, or LinkedIn URL | | bulk_enrich_people | Bulk enrich up to 10 people at once |

Organizations

| Tool | Description | |------|-------------| | search_organizations | Search companies by name, size, and other filters | | enrich_organization | Enrich a company by domain (industry, size, funding, tech stack) | | get_organization | Get full organization details by ID |

Sequences (Email Campaigns)

| Tool | Description | |------|-------------| | search_sequences | List or search email sequences | | get_sequence | Get sequence details and steps | | add_contacts_to_sequence | Add contacts to an email sequence | | remove_contacts_from_sequence | Remove contacts from a sequence | | list_email_accounts | List connected email accounts (needed for sequences) |

Tasks

| Tool | Description | |------|-------------| | search_tasks | Search tasks by status, type, or contact | | create_task | Create a follow-up task (call, action item, LinkedIn) |

Deals

| Tool | Description | |------|-------------| | search_deals | Search deals/opportunities | | create_deal | Create a new deal with amount, stage, and close date |

Use Cases

With Claude Desktop

Just talk naturally. Claude chains the tools automatically.

Prospecting a new market

"Search for cybersecurity companies in Spain with 50-200 employees. Enrich the top 5 and create contacts for their IT Managers. Add them to my outreach sequence."

Claude will:

search_organizations → find matching companies
enrich_organization × 5 → get full company data
create_contact × N → add the contacts to your CRM
list_email_accounts → get your sender account
add_contacts_to_sequence → start the email campaign

Lead enrichment

"I got these leads from a conference: john@acme.com, sarah@globex.com, mike@initech.com. Enrich all of them and add the ones with VP+ titles to my CRM."

Pipeline management

"Create a deal for Acme Corp at $15,000, stage 'Proposal Sent', closing end of month. Also create a follow-up call task for next Tuesday."

Research before a call

"Look up the contact Jane Smith at Stripe. Also enrich Stripe's company profile so I have context for the call."

With n8n

You can integrate Apollo into n8n workflows in multiple ways:

Option A: Direct HTTP Requests (simplest)

Use n8n's HTTP Request node to call Apollo's API directly. The endpoints and payloads are the same ones this MCP server uses.

Example — Enrich a lead on form submission:

Webhook (new lead)
  → HTTP Request: POST https://api.apollo.io/api/v1/people/match
    Headers: { "x-api-key": "{{$env.APOLLO_API_KEY}}" }
    Body: { "email": "{{$json.email}}", "api_key": "{{$env.APOLLO_API_KEY}}" }
  → IF (title contains "VP" or "Director")
    → HTTP Request: POST https://api.apollo.io/api/v1/contacts
      Body: { "first_name": "...", "last_name": "...", "email": "..." }
    → Slack: "New qualified lead added to Apollo"

Option B: n8n AI Agent + Claude + MCP

Use n8n's AI Agent node with Claude as the LLM. The agent can use Apollo MCP tools to make decisions:

Trigger (Cron: Monday 9am)
  → AI Agent (Claude model, Apollo MCP tools)
    Prompt: "Search for SaaS companies in Germany with 100-500 employees.
             Enrich the top 10 and add qualified leads to my CRM."
  → Slack: summary of leads added

Example n8n Workflows

1. Inbound Lead Qualification

Typeform/Webhook → Enrich Person → Score Lead → Create Contact → Add to Sequence → Slack Alert

Trigger: form submission or webhook. Enrich the lead with Apollo. If they match your ICP (right title, company size), create a contact and drop them into an email sequence. Notify your team on Slack.

2. Weekly Prospecting Pipeline

Cron (weekly) → Search Organizations → Filter by ICP → Enrich Companies → Bulk Create Contacts → Add to Sequence → Google Sheets Log

Every Monday, search for new companies matching your criteria, enrich them, create contacts for decision-makers, and start outreach automatically.

3. Deal Creation from CRM Events

Webhook (meeting booked) → Get Contact → Create Deal → Create Task (follow-up) → Slack

When a meeting is booked (e.g., from Calendly), automatically create a deal in Apollo and schedule a follow-up task.

4. Contact Enrichment Pipeline

Google Sheets (new rows) → Loop → Enrich Person → Update Sheet → IF no email → Flag for manual review

Bulk enrich a list of contacts from a spreadsheet. Update with enriched data and flag any that couldn't be matched.

Project Structure

apollo-mcp/
├── main.py              # FastMCP server entry point, lifespan, mounts
├── client.py            # Shared async HTTP client (auth, error handling)
├── tools/
│   ├── __init__.py
│   ├── contacts.py      # 6 tools — CRUD + search + bulk create
│   ├── people.py        # 2 tools — single and bulk enrichment
│   ├── organizations.py # 3 tools — search, enrich, get
│   ├── sequences.py     # 5 tools — sequences + email accounts
│   ├── tasks.py         # 2 tools — search + create
│   └── deals.py         # 2 tools — search + create
├── .env.example
├── .gitignore
└── README.md

Architecture

client.py — ApolloClient wraps httpx.AsyncClient. Sends the API key in both the x-api-key header and in the request body (some Apollo endpoints require it in the body). All HTTP errors are caught and returned as descriptive dicts — tools never throw exceptions.
main.py — Uses FastMCP's lifespan pattern to create the HTTP client on startup and close it on shutdown. Each tool module defines its own FastMCP sub-server, which gets mounted into the root server.
tools/*.py — Each file defines a FastMCP sub-server with @server.tool decorated async functions. Tools access the shared client via ctx.lifespan_context["apollo"].

Error Handling

All tools return structured error messages instead of raising exceptions:

| Status | Meaning | |--------|---------| | 401 | Invalid or missing API key | | 404 | Resource not found | | 422 | Validation error (with details from Apollo) | | 429 | Rate limit exceeded — wait and retry | | Network error | Connection/timeout issue |

Example error response:

{
  "error": "Rate limit exceeded. Wait and retry.",
  "status": 429
}

API Key Permissions

| Endpoints | Regular Key | Master Key | |-----------|:-----------:|:----------:| | Search contacts/organizations | Yes | Yes | | Create/update/delete contacts | Yes | Yes | | People & org enrichment | Yes | Yes | | Get contact/organization by ID | No | Yes | | Sequences (list, add/remove contacts) | No | Yes | | Tasks (list, create) | No | Yes | | Deals (list, create) | No | Yes | | Email accounts | No | Yes |

Recommendation: Use a master API key to access all 20 tools.

Requirements

Python 3.11+
FastMCP 3.x
httpx
python-dotenv
An Apollo.io account with API access

Contributing

Contributions are welcome! Some ideas:

[ ] Add more Apollo endpoints (labels, lists, custom fields)
[ ] Add webhook support for real-time events
[ ] Create a pyproject.toml for proper packaging
[ ] Add rate limit retry with backoff
[ ] Add response filtering to reduce payload size

License

MIT — see LICENSE.