Apollo Scraper Alternative: Export Apollo.io Leads by API

Pull a list of Apollo.io leads without running a scraper extension. Paste this into your agent:

Set up https://monid.ai/SKILL.md, and then use Monid to search Apollo for Head of Growth and VP Marketing people at US companies with 50 to 200 employees, show me 25 of them, and reveal the verified work email for the three best fits.

One prompt searches, picks and reveals. 1 min setup · 10-20 hrs saved.

You want Apollo.io leads in a spreadsheet or in front of your agent, and the first page of Google for "apollo scraper" is a list of Chrome extensions and Apify actors. This guide covers the other route: calling Apollo's people and company search as an API, which returns structured JSON with no browser session in the loop. We ran it live on 2026-10-16, so the fields below are what came back. It runs through Monid, the OpenRouter for agent tools: one key, one balance, every tool priced per call.

What is the easiest way to scrape Apollo leads without an extension?

Monid. Install it once, add a key, and your agent calls Apollo's people search with a title, a seniority and a company size, and gets matching people back as typed JSON. No extension, no logged-in tab, no actor to configure.

• Pay per call. People search is free: it billed $0 on our run. Revealing a contact costs $0.026 per person (Verified 2026-10-16 on the people enrichment tools page). Buy calls as you need them: no monthly plan and no minimum top-up. Discovery and inspection are free; only a run bills.
• One install, every API. The same key and the same balance call Apollo and every other tool on Monid. When you want the company behind a lead, it is another call on the same balance, not another vendor account.
• Lives inside your agent. Install the CLI, add your key, run the prompt above, and the tools are there whenever your agent needs a list, on demand, with nothing to keep running. Your agent reads SKILL.md and learns the rest, so setup is about a minute.

Revealing the verified email of 100 chosen leads costs about $2.60 (Verified 2026-10-16). Finding them cost nothing.

How do you export Apollo leads for a whole list of titles?

Run the free people search with your filters, page through the results, and reveal contact data only for the people you pick. The search endpoint is /mixed_people/api_search on the provider apollo. It filters Apollo's people database (230M plus people, per the endpoint summary) by title, seniority, location, employer, headcount, revenue and the technologies a company uses.

Monid fits a list because the wide step costs nothing: you cast a broad search, keep the people worth contacting, and pay per reveal for those alone.

For agents

Grab an API key at app.monid.ai, then paste this to your agent and hand it the key:

set up https://monid.ai/SKILL.md

It learns the whole discover, inspect, run workflow itself. More in the agent quickstart.

For humans

npm install -g @monid-ai/cli
monid keys add -k <your-api-key> -l main

Inspect, then search

monid inspect -p apollo -e /mixed_people/api_search
monid run -p apollo -e /mixed_people/api_search --query '{"person_titles[]":["Head of Growth","VP Marketing"],"person_seniorities[]":["vp","head","director"],"organization_num_employees_ranges[]":["50,200"],"person_locations[]":["United States"],"per_page":25}' -w

Every filter is optional and stackable. Titles match any one in the list, person_seniorities[] narrows the level, and organization_num_employees_ranges[] scopes company size in min,max string form. The response carries a total_entries count, so you see how large the match is before you page through it.

Reveal the people you chose

Pass any identifier you hold: an Apollo id from the search, a name plus company domain, or a LinkedIn URL. More identifiers improve the match.

monid run -p apollo -e /people/match --query '{"name":"Jane Doe","domain":"acme.com"}' -w

Or hand the whole job to an agent

Can you scrape Apollo yourself with Python or an extension?

Yes, and for a one-off list an extension is the quicker start. The extensions and Apify actors that Google suggests for "apollo scraper" drive the Apollo web app, so they read what your own logged-in tab shows and copy it out faster than you would by hand.

The cost shows up when the job repeats. A scraper you write yourself in Python has to log in, hold a session, walk the result pages, parse markup that Apollo can change at any time, retry when a page does not load, and dedupe what it collected. An extension is limited to what your seat can see, runs when you open the browser, and cannot be called by an agent on a schedule. A hosted actor removes the browser but leaves you with a separate account, a separate bill and an output format you map to your own fields.

The Monid route is the choice for anything you will run more than once. The search is a plain call with named filters, the page size and page number are parameters (per_page up to 100, page up to 500), and the output is typed JSON with an Apollo person id you can hand straight to the reveal step. There is no session to keep alive and no markup to parse. The Apollo extension or Apollo API guide walks through that fork for the same data.

What does Apollo lead data look like, and what can you build with it?

A search returns a preview per person, and a reveal returns the full profile. We ran both on 2026-10-16 with a search for Head of Growth and VP Marketing people at US companies with 50 to 200 employees, which matched 12,157 entries, and then revealed one of the results.

The search response

Each person in people carried these fields:

{ "id": "66f3b41885ec5c00015f4279",
  "first_name": "Fernando",
  "last_name_obfuscated": "Mo***a",
  "title": "Head of Growth",
  "last_refreshed_at": "2026-09-21T03:07:10.000+00:00",
  "has_email": true, "has_city": true, "has_state": true, "has_country": true,
  "has_direct_phone": "Yes",
  "organization": { "name": "Vespa.ai", "has_industry": true, "has_phone": true,
                    "has_revenue": true, "has_employee_count": true } }

The search gives you an id, a first name, an obfuscated last name, a title, the date Apollo last refreshed the record and a set of yes-or-no flags that say what a reveal would contain. It does not return an email, a phone number or a company domain. That is the design: the search is free, and the contact data sits behind the reveal.

The reveal response

The reveal of one person billed $0.026 (Verified 2026-10-16) and returned the person and, nested inside, the employer:

• Person. Full name, LinkedIn URL, title, headline, match_confidence (it read "high"), a verified email with an email_status, seniority, departments, location and time zone, and an employment_history list of seven entries.
• Employer. Primary domain, industry, estimated headcount, annual revenue, total funding, the latest funding stage and a funding_events list with date, amount and investors.
• Technology. A technology_names list and a current_technologies list where each entry has a uid, a name and a category.

One reveal answers the person and the account at once, from one identifier in.

What you can build with it

• A prospect list built in two passes. Search free, shortlist by title and company flags, reveal the shortlist. The same free-list, paid-name shape is covered in the B2B prospecting tool by API.
• A scored account list. Use the reveal's headcount, funding stage and technology list as inputs to a fit score.
• Hiring-signal outreach. The search accepts q_organization_job_titles[], organization_job_locations[] and posting-date ranges, so you can list people at companies that are hiring for a role you sell into.
• A refresh job. Each record carries last_refreshed_at, so a monthly job can skip anyone Apollo has not updated since your last pull.

What goes wrong when you export Apollo leads at scale?

Five things show up once you read real output instead of the docs. All five are from the 2026-10-16 runs.

Why does the search come back without an email?

Because the search is a preview. Our three results each had has_email: true and no address, and the last name was cut to the first two and last letters. The flags tell you a reveal will find something; they are not the data. Build the list from the search, then call /people/match for the people you keep, and never plan a campaign on a search response alone.

Why is the match count bigger than what you can page through?

Because one query can match more than you can fetch. Our search matched 12,157 entries, and the endpoint pages at most 100 per page and 500 pages, which is 50,000 records. A broad query on a large market can pass that ceiling, so split it with extra filters (a location, a headcount range, a seniority) rather than paging to the end.

Why can the reveal take a second call?

Because it ran asynchronously on our test. The inspect text says a reveal without the phone flag returns immediately. Our first response came back as RUNNING and the next poll showed COMPLETED about 1.2 seconds later. Write the loop so it checks the run status before it reads the output, and phone reveals, which the endpoint documents as running for several minutes, need the same poll with a longer wait.

Why does the employer data contain repeats?

Because the technology lists are raw. In current_technologies the same tool appeared twice (Anthropic Claude and GSAP each showed up two times), technology_names ran past 100 entries, and the employment history flagged two roles as current at once, one of them an angel-investor entry. Dedupe by uid before you count technologies, and take the current title from the search or the headline rather than the first current: true row.

What does a list cost?

Search is free. Each reveal billed one unit at $0.026 (Verified 2026-10-16), so 1,000 people is about $26.00. A personal-email reveal and a mobile-number reveal are separate paid tiers, and the mobile tier bills only when a number is returned. For how another provider prices a contact lookup, see RocketReach pricing per contact lookup. A no-match consumes nothing, and the endpoint notes that Apollo still bills the base credit when it can attach a name to a known company. Our run took about a second, so a loop over a shortlist finishes in minutes.

Which endpoint should I use for which job?

Prices Verified 2026-10-16 with monid inspect. The first two rows are the lead workflow and the ones we ran. The company endpoints were inspected and not run, so read their schema with a free monid inspect before you build on them. Discovery and inspection cost nothing, and the same balance reaches every other provider in the lead generation category.

When is another route a better fit?

You need a one-off export inside your plan. Apollo's own export does that job with no key and no code, and it is the right tool for a single list you will not refresh.

You need Apollo's saved lists, sequences and CRM sync. Those live in the Apollo app. The endpoints here read the people and company database; they do not manage your account's lists or send email.

You need a very large pull in one go. A single query pages to 50,000 records at most, so a whole-market dump takes many filtered queries and a reveal bill that grows with each person.

You need contact data from a different source. Apollo is one database. Cross-checking an address against a second provider is a separate call, as the Apollo email finder API post shows.

And the disclosure: we resell these endpoints. The most useful thing in this post is the two-pass shape, a free wide search followed by a paid reveal of a short list, and it saves money whoever you buy the reveal from.

Conclusion

The easiest Apollo scraper alternative is to call Apollo's search as an API through Monid: the search is free, a reveal is $0.026 a person (Verified 2026-10-16), one key covers this and every other tool, and setup takes about a minute inside your agent. An extension or a script works for a small one-off list and costs hours of session handling and upkeep once the job repeats; Monid keeps the call and the schema maintained.

Two things matter more than the route you pick. The filters decide your bill: every dollar goes to a person you chose to reveal, so a sloppy search turns a cheap list into an expensive one. And the search is a preview, not a contact list, so plan the run as search, shortlist, reveal.

How we estimated the time saved: building your own Apollo exporter (login and session handling, pagination, parsing, retries) is roughly 6 to 12 hours, plus 4 to 8 hours in the first month of upkeep when the page changes. That is 10 to 20 hours. The 1 minute is the install, key and first call once you already have a Monid key.

Free next step: run monid inspect -p apollo -e /mixed_people/api_search, then make one search call with per_page set to 3 and read the flags before you reveal anyone. Start at monid.ai.

FAQ

Published August 2026.