Apollo APIapollo.io ↗
Search Apollo.io's database for people by title, location, and seniority. Enrich profiles with emails, LinkedIn URLs, employment history, and company data.
What is the Apollo API?
The Apollo.io API exposes 2 endpoints that let you search millions of professional profiles and enrich individual records with structured contact data. search_people accepts filters for job title, location, seniority, and keywords, returning up to 50,000 paginated results per query. enrich_person resolves a partial identity — name, company domain, or Apollo ID — into a full profile including work email, employment history, and organization details.
curl -X GET 'https://api.parse.bot/scraper/44e172e6-9a69-4721-8555-7db5ee8c16f2/search_people?per_page=5&max_pages=1&person_titles=Software+Engineer&person_locations=San+Francisco%2C+California%2C+United+States&api_key=demo_key' \ -H 'X-API-Key: $PARSE_API_KEY'
Typed, relational, agent-ready
A generated client with real types, enums, and the links between objects — the structure a flat JSON response can't carry. Autocompletes in your editor and reads cleanly to coding agents.
- Fully typed · autocompletes
- Objects link to objects
- Typed errors & pagination
Typed Python client. Set up the SDK in your uv project, then pull this API’s typed client:
uv add parse-sdk uv run parse init uv run parse add --marketplace apollo-io-api
uv run parse add --marketplace pulls a pinned snapshot of this canonical API — it won’t change underneath you. To customize it, subscribe and swap to your own copy.
"""Apollo.io People Search & Enrichment — bounded, re-runnable walkthrough."""
from parse_apis.apollo_io_people_search___enrichment_api import (
Apollo, Seniority, PersonNotFound
)
client = Apollo()
# Search for engineering directors in San Francisco
for person in client.personsummaries.search(
person_titles="Software Engineer",
person_locations="San Francisco, California, United States",
person_seniorities=Seniority.DIRECTOR,
per_page=10,
limit=5,
):
print(person.name, person.title, person.company)
# Drill-down: take one result and enrich for full profile
summary = client.personsummaries.search(
person_titles="Product Manager",
person_locations="New York, New York, United States",
limit=1,
).first()
if summary:
# Navigate from summary to full detail via the instance method
detail = summary.enrich()
print(detail.name, detail.email, detail.title)
if detail.organization:
print(detail.organization.name, detail.organization.industry)
if detail.employment_history:
for job in detail.employment_history[:3]:
print(job.title, job.organization_name, job.current)
# Match a person by name and company (alternative enrichment path)
try:
matched = client.people.match(
first_name="Sundar",
last_name="Pichai",
organization_name="Google",
domain="google.com",
)
print(matched.name, matched.title, matched.linkedin_url)
except PersonNotFound as exc:
print(f"Person not found: {exc}")
print("exercised: personsummaries.search / summary.enrich / people.match")
Full-text and filtered search over Apollo's people database. Accepts title, location, seniority, keyword, and company-size filters. Pagination is handled internally: page and max_pages control the window fetched in one call (up to 100 results per page, 500 pages max). Returns a flat list of person summaries with basic contact metadata. Does not consume Apollo credits on the free tier.
| Param | Type | Description |
|---|---|---|
| page | integer | Starting page number (1-500) |
| api_keyrequired | string | Apollo.io API key. Get from Settings > Integrations > API Keys in your Apollo account. |
| per_page | integer | Results per page (1-100) |
| max_pages | integer | Maximum number of pages to fetch (each page = up to 100 results) |
| q_keywords | string | Keyword search string to filter results |
| person_titles | string | Comma-separated job titles to filter by (e.g., 'Software Engineer,Product Manager') |
| person_locations | string | Comma-separated locations to filter by (e.g., 'San Francisco, California, United States') |
| person_seniorities | string | Comma-separated seniority levels to filter by. Accepted values: senior, manager, director, vp, c_suite, entry, owner, partner, intern |
| contact_email_status | string | Comma-separated email status filters (e.g., 'verified,likely to engage') |
| include_similar_titles | boolean | Include people with similar job titles |
| organization_num_employees | string | Comma-separated employee count range boundaries (e.g., '1,10,11,20,21,50') |
{
"type": "object",
"fields": {
"people": "array of person summary objects with id, name, title, company, location, linkedin_url, seniority, and other metadata",
"page_start": "integer - starting page number",
"pages_fetched": "integer - number of pages retrieved",
"results_count": "integer - number of people returned in this response",
"total_entries": "integer - total matching results available"
}
}About the Apollo API
search_people
The search_people endpoint accepts filters including person_titles (comma-separated job titles), person_locations (city, state, or country strings), person_seniorities (e.g. senior, director, c_suite), and a free-text q_keywords field. Pagination is controlled via page (1–500), per_page (1–100), and max_pages. Each response includes a people array alongside total_entries, results_count, and pages_fetched so you can track progress across large result sets. This endpoint does not consume Apollo credits regardless of result volume. Note that on Apollo's free tier, last_name values may be obfuscated in search results.
enrich_person
enrich_person takes at least one identifier — a person_id from a prior search, a linkedin_url, or a combination of first_name, last_name, and organization_name or domain — and returns a resolved profile. Response fields include email, title, company, city, state, country, and the Apollo id for downstream lookups. Setting reveal_phone_number to true will attempt to surface a direct phone number, but doing so consumes Apollo credits according to your plan tier.
Data Coverage and Limitations
Search results reflect Apollo's contact database, which skews toward English-speaking markets and professional roles documented on LinkedIn and company websites. Last names in search_people results may be masked on free-tier keys; full names require an Apollo account with sufficient access. The enrich_person endpoint returns email as a top-level string field — bulk email retrieval across large search sets would require iterating enrichment calls and managing credit consumption accordingly.
The Apollo API is a managed, monitored endpoint for apollo.io — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when apollo.io changes and a check fails, the API is automatically queued for repair and re-verified. It is built to keep working as the site underneath it changes.
This isn't an official apollo.io API — it's an independent, maintained REST wrapper over public data. Where the source has no official API (or only a limited one), Parse gives you a stable contract over a source that never promised one, and keeps it current. Need a new endpoint or field? You can revise it yourself in plain English and the agent rebuilds it against the live site in minutes — contributing the change back to the shared API is free.
Will this API break when the source site changes?+
Is this an official API from the source site?+
Can I fix or extend this API myself if I need a new endpoint or field?+
What happens if I call an endpoint that has an issue?+
- Build a targeted outreach list by filtering
search_peopleonperson_titleslike 'VP of Engineering' andperson_locationslike 'New York' - Resolve a LinkedIn URL to a verified work email using
enrich_personwith thelinkedin_urlparameter - Qualify inbound signups by enriching their name and company domain to retrieve
title,seniority, andcompanyfields - Segment a contact database by seniority using the
person_senioritiesfilter to isolate C-suite or director-level contacts - Retrieve employment history and organization metadata for a known Apollo
person_idto keep CRM records current - Paginate through up to 50,000 keyword-matched profiles using
q_keywordsandmax_pagesfor market research datasets
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 100 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
One credit = one API call regardless of which marketplace API you call. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.
Does Apollo.io have an official developer API?+
What does `enrich_person` return compared to `search_people`?+
search_people returns summary-level fields: name, title, company, location, linkedin_url, and Apollo's internal id. enrich_person resolves those into a full record that adds email, split address fields (city, state, country), first_name, last_name, employment history, and optionally a phone number. You typically chain the two: search to get IDs or LinkedIn URLs, then enrich specific records.Why are last names sometimes missing or obfuscated in search results?+
last_name fields in search_people responses for accounts on its free tier. Full last names are returned when your Apollo API key is associated with a paid plan that includes full contact reveal. The enrich_person endpoint similarly returns complete name data only when your plan permits it.Does the API return company firmographic data like employee count or revenue?+
How does pagination work for large searches?+
search_people supports up to 500 pages with up to 100 results per page, for a maximum of 50,000 results per query. Use the page, per_page, and max_pages parameters together. The response always includes total_entries so you can calculate how many pages remain before issuing the next request.