---
name: apollo-reverse-contact-integration
description: Connect Apollo and Reverse Contact: what syncs, which editions carry it, the setup order, and the failures to expect. Covers contacts, companies. Use when the user wants to set up, audit or troubleshoot Apollo and Reverse Contact together, or asks why data is not moving between them.
---

# Apollo and Reverse Contact

> Generated from https://www.reversecontact.com/integrations-hub/apollo-integrations/apollo-reverse-contact-integration
> Every tier requirement, sync direction and limit below was read from the vendors' own documentation on 2026-10-28.
> Vendors change these without notice. Re-check anything load-bearing before you rely on it.

**What you have to buy first:** An Apollo paid plan for API enrichment, a Reverse Contact API key, and an orchestrator to run the waterfall

**What moves:** contacts, companies, one way, out of Apollo.
**How it is built:** built on the api, zapier, make or n8n. **Effort:** hours.

## The short version

These are competitors, so the honest page is a waterfall rather than an integration, and the useful finding is not about coverage. It is that Apollo is itself a waterfall over data partners your admin configures, which means Apollo cannot tell you in advance what a call will cost or whether a miss is billed, and its documentation says exactly that. Reverse Contact publishes a credit cost per endpoint and a flat rule that errors are free. Those are two different products wearing the same category name, and knowing which one you are buying matters more than either coverage figure.

## What each route tells you before you call it

Rows: The route. Columns: What you can know in advance. Comparing coverage is the obvious thing to do here and the least useful, because neither figure predicts your list. What you can compare properly is predictability: whether the cost of a call is published, whether a miss is billed, whether the answer arrives in the response, and whether any plan stops metering it. Every cell is from the vendor's own documentation.

| The route | The per-call cost is published | A miss is free | The answer is in the response | Some plan stops metering it |
|---|---|---|---|---|
| Apollo search over its database | Not published | Not published | Synchronous | Always on credits |
| Apollo waterfall for email or phone | Depends on your config | Depends on your config | Webhook only | Always on credits |
| Reverse Contact from an email or domain | Published | Free | Synchronous | Unmetered from $699 |
| Reverse Contact from a profile URL | Published | Free | Synchronous | Unmetered from $249 |
| Reverse Contact Find Email or Find Phone | Published | Free | A task id to poll | Always on credits |

- **Published.** Reverse Contact publishes a credit cost per endpoint: nothing for a freshness check or a search count, 1 for a cached lookup from a profile URL, 2 for a reverse lookup, 3 for a business email and 20 for a direct phone number.
- **Depends on your config.** Apollo says waterfall credit usage depends on the data requested, your plan, your team's configuration, the data sources attempted and each source's pricing rules, and that some sources charge only on a result while others may charge for a lookup that finds nothing. That is a straight answer and it is not a number.
- **Not published.** Apollo publishes a per-seat annual credit grant, 30,000 on Basic and 48,000 on Professional, rather than a cost per call, so what an individual search costs and what it costs when it finds nothing are not stated in the material cited here.
- **Free.** Every 4xx and 5xx is 0 credits, and Find Email and Find Phone are charged only when something is found. The exception is a live fetch, which is the one Reverse Contact endpoint whose 2 credits are kept even when no profile is found, and it is not a row on this grid.
- **Synchronous.** The result comes back in the response to the call you made, which is what lets it run inside a CRM workflow, a Clay column or a 30-second spreadsheet function.
- **Webhook only.** Apollo requires a valid webhook_url on every waterfall request and does not return phone numbers in the synchronous reply, so a build that reads only the immediate response will conclude that phones are never found.
- **A task id to poll.** Both finders return a task id to poll with check_task. Polling is free and off the rate-limit clock, which makes this workable, but nothing waits for it inside a CRM.
- **Unmetered from $249.** Cached lookups from a profile URL stop being metered on Go at $249 a month, which makes the identifier your list already carries the single biggest lever on the bill.
- **Unmetered from $699.** Reverse lookups from an email, a name or a domain stop being metered only on Max at $699 a month, and people and company search on Plus at $449 in between.
- **Always on credits.** Stays on credits on every plan. Apollo meters out of a per-seat annual grant throughout, and Reverse Contact keeps Find Email, Find Phone and live refreshes on credits on every plan including Platform, where they move to a volume rate.

Counted off that grid, of twenty pairings: three give you published, two give you depends on your config, two give you not published, three give you free, three give you synchronous, one gives you webhook only, one gives you a task id to poll, one gives you unmetered from $249, one gives you unmetered from $699, three give you always on credits.

Read the first two columns of the second row together, because that is the finding and it is not a criticism. A waterfall over partners somebody configures cannot publish a per-call price or a miss policy, since both depend on which partners are in it, and Apollo says so plainly. The cost of predictability is the bottom row, where Reverse Contact is also asynchronous and also never unmetered, which is worth printing on a page its publisher pays for.

## What actually syncs

Direction is written from Apollo's point of view: out means out of Apollo, in means into it.

| What | Direction | What that means in practice |
|---|---|---|
| Nothing | One way, out | There is no sync between two data providers, no app on either side and nothing to configure between them. |
| The first call | One way, out | Whichever provider suits the identifier you hold, in Clay, n8n or your own code. |
| The fallback | One way, out | The other provider, on the rows that came back null. This is the only sense in which the two are connected. |
| The verification | One way, out | A separate step at the end, which almost every practitioner who has built this says they added. |

## Which field lands where

There is nothing to map between two data providers. What is worth laying out is what each call costs, what each one returns when it fails, and what the published coverage figures actually count, because that last one is where most comparisons of these two go wrong.

| In Apollo | In Reverse Contact | What to know about the match |
|---|---|---|
| An email, a name or a domain | Reverse Contact: 2 credits, unmetered from $699 | Identity, the current role, history and the company on one schema. A miss returns null with a confidence score and costs nothing. |
| A profile URL | Reverse Contact: 1 credit, unmetered from $249 | Half the price, same schema. The identifier you hold decides the bill more than the plan does. |
| A set of filters, looking for new people | Apollo search, or Reverse Contact people search | Apollo's paid plans allow 200 search requests a minute, 6,000 an hour and 50,000 a day. Reverse Contact charges 1 credit per profile delivered and nothing for the count endpoint that sizes the result first. |
| A record missing an email or a phone | Apollo waterfall, with run_waterfall_email or run_waterfall_phone | Needs a webhook_url, and phone results come back only at the webhook. The sources queried, and what a miss costs, are whatever your admin configured. |
| The same gap | Reverse Contact Find Email at 3, Find Phone at 20 | Charged only when one is found, asynchronous, returning a task id to poll with check_task. These stay on credits on every plan. |
| A record you think is stale | The free check, then a 2-credit live refresh | The check costs nothing and says when the profile was last updated. The live refresh is the one call here billed even when it finds nothing. |
| Either provider's answer | A verifier, before a sequence | Resolved is not deliverable. This step is in every practitioner account of this build and in neither vendor's quickstart. |
| Anything between the two | Nothing at all | No sync, no app, no shared record. The orchestrator is the only thing that knows both exist. |

### What each side publishes, and why the numbers do not divide

The coverage comparison is the reason a page like this is usually not written, so here it is with each figure attributed to the vendor that publishes it. The point of the table is the second column: these are not the same unit, and a ratio between them is arithmetic rather than information.

| The published figure | What it actually counts |
|---|---|
| Reverse Contact: 800M+ profiles, 70M+ companies | Public professional profiles. A profile is an identity you can resolve to, not a mailbox you can write to, and the product is built around going from an identifier you hold to one of these |
| Apollo: 240M contacts, 30M companies | Contact records in a database you search. A contact is a person with contact details attached, which is a smaller and more expensive thing to assemble than a profile |
| The ratio between them, about three to one | Nothing you can act on. Three times as many profiles is not three times as many people you can email, because the two numbers are not counting the same object |
| Reverse Contact: a 70%+ identity match rate | A global average across their whole corpus, published as one, with the instruction to measure your own on 500 rows. It is not a prediction about your list |
| Apollo: no published match rate | Their documentation instead names the identifiers that improve one, which is first and last name, a LinkedIn URL, or an email. That is more useful than a number and it is not comparable to one |
| Reverse Contact: 200M refreshes a month | How often the corpus is revisited, which is the figure that decides whether a record resolved today reflects this year. Apollo publishes no equivalent in the material cited here |
| What a competitor publishes about Apollo | A different number again. ZoomInfo's own site gives Apollo 270M contacts and 70M companies, against Apollo's own 240M and 30M, which is the clearest possible argument for only ever quoting a vendor about itself |

**What does not cross:**

- An integration between the two. There is no app, no sync and no shared object, and a waterfall is something your orchestrator does rather than something either vendor provides for the other.
- A dollar cost per enriched record for either side. Apollo grants credits per seat per year and Reverse Contact sells packs and plans, and dividing either by a record count would be our arithmetic wearing their authority.
- A single answer to what an Apollo waterfall miss costs. Apollo states that it depends on the data requested, your plan, your team's configuration, the sources attempted and each source's pricing rules.
- A recommendation based on coverage alone. Both figures are statements about a corpus, and the only figure that decides anything is the one you measure on your own rows.

## Connect it, in this order

**Who has to do it:** Somebody who can create an Apollo API key on a paid plan, somebody who can create a Reverse Contact key, and whoever owns the orchestrator.
**How long:** An afternoon to build. A week to get a result you believe.

### 1. Write down the question before choosing a provider, because this decides everything else

*Where:* Your own notes, not a tool

Finding people you did not know about is a search problem and resolving somebody you already hold is a lookup problem. They have different costs, different failure modes and different providers, and a waterfall that mixes them pays search prices for rows that only needed resolving.

### 2. Audit which identifier your rows already carry

*Where:* Your CRM, your list or your warehouse

A profile URL is a 1-credit cached lookup on Reverse Contact and unmetered from the $249 plan. An email, a name or a domain is 2 credits and unmetered only from $699. Apollo separately advises a name, a LinkedIn URL or an email for better match rates, so the audit pays off on both sides.

### 3. Create both keys, and spend the trials rather than a budget

*Where:* Apollo and Reverse Contact

Reverse Contact gives a trial with no card and 500 credits on a new account, which is 500 profile-URL lookups or 250 reverse ones, and it runs until those credits are spent rather than for a number of days. Apollo grants 30,000 credits per seat per year upfront on Basic, so a pilot there is a draw against a budget you have already committed.

### 4. Decide the order by cost of a miss, not by coverage

*Where:* Your orchestrator

The provider whose misses are free belongs first, because the rows it cannot resolve cost nothing to discover. On Reverse Contact that is every endpoint except a live fetch; on Apollo's waterfall it depends on which sources your admin configured, so find that out before fixing the order.

### 5. Check before you fetch, on the endpoint that costs nothing

*Where:* POST /v2/fetch/persons/check

The free check says whether a profile is cached and when it was last updated, so a second pass over a list pays only for what has moved. On a bake-off this also tells you how much of one provider's apparent advantage is simply a fresher copy of the same record.

### 6. Give the webhook somewhere to land before calling the waterfall

*Where:* Apollo: webhook_url on the request

Apollo requires a valid webhook_url on every waterfall request and does not return phone numbers in the synchronous response. A build that reads only the immediate reply will report that phones are never found, which is a configuration error that looks exactly like a coverage result.

### 7. Add the verification step, because everybody who has done this says to

*Where:* A verifier, at the end

Every practitioner account of this build ends with a verification step, and several describe paying for verified addresses that bounced anyway. A resolved identity and a deliverable address are two different claims and only one of them is what a sequence needs.

### 8. Count the resolved rate and the bounce rate separately

*Where:* Your bake-off sheet

A provider can identify the right person and give you a dead address, or give you a live address for the wrong person, and a single accuracy number hides both. Reverse Contact returning null with a confidence score rather than a guess is only worth something if your count distinguishes a refusal from a mistake.

### 9. Decide what a null does before the first production run

*Where:* Your orchestrator

Fall through to the other provider, queue for review, or write nothing. All three are defensible and the one that is not is writing a low-confidence guess into a field that a rep will read as a fact.

Only the first step is expensive to get wrong, and it is a question rather than a configuration: find somebody, or resolve somebody. Everything after it is an afternoon of plumbing and a week of counting, and the counting is the part that produces an answer you can defend to whoever is paying for both.

## How to check it worked

- Run the same 500 rows through both, in both orders, and compare the totals. If the order changes the result by more than the overlap, one of the two is being asked the wrong question.
- Count what each provider does when it does not know. A null with a confidence score and a plausible wrong answer cost the same and are not the same, and only your count can tell them apart.
- Deliberately send a waterfall request to Apollo with no webhook and read what comes back. Knowing that phones arrive only at the webhook is better learned in a test than from a coverage report.
- Verify a sample of addresses from both and record bounces separately from misses. Several practitioners describe paying extra for verified emails that bounced, and the only defence is your own count.

## When it goes wrong

Each row is a symptom somebody reports, the documented reason, and the fix. Work down it before escalating to either vendor, because most of these are configuration.

| Symptom | Why it happens | What to do |
|---|---|---|
| The waterfall never returns a phone number | Apollo requires a webhook_url on every waterfall request and phone results are not in the synchronous response. | Stand the webhook up first and confirm it receives a test payload. This failure is indistinguishable from a coverage problem and has been mistaken for one. |
| The credit burn is far higher than the pilot suggested | A waterfall was ordered by coverage rather than by what a miss costs, so the rows nobody could resolve were discovered expensively. | Put the provider whose misses are free first. Find out which of your configured Apollo sources charge on a lookup rather than on a result, since Apollo states that both kinds exist. |
| A search was run on rows that already had an email | Find somebody new and resolve somebody you hold were treated as the same operation, which is the mistake step one of the checklist exists to prevent. | Split the list by the identifier it carries. Rows with an email or a profile URL go to a lookup, and only the rows with neither need a search. |
| The verified emails bounced | Resolution and deliverability are two different claims, and neither provider's match is a delivery guarantee. | Add a verification step before anything reaches a sequence, and count bounces separately from misses. Every practitioner account of this build includes this step and neither vendor's quickstart does. |
| A 429 from Apollo on a backfill | General endpoints allow 200 a minute, 400 an hour and 2,000 a day on Basic and Professional, with Organization at 200, 600 and 6,000. | Honour the retry-after header and check which plan the key belongs to, because the hourly and daily figures differ between Basic and Organization while the per-minute one does not. |
| 429 DAILY_EXTRACTION_LIMIT_EXCEEDED on an Unlimited plan | Reverse Contact's covered calls are unmetered up to 100,000 profiles per workspace per UTC day and refused after that until midnight UTC. | Spread the job across UTC days. The minute limit is 100 on Go, Plus and Max alike, so a bigger plan buys unmetered families rather than a faster backfill. |
| The two providers disagree about where somebody works | A cached database is as current as its last refresh, and the two corpora are refreshed on different schedules. | Treat the disagreement as the signal rather than as an error, and check the update date. Reverse Contact's free check returns when the profile was last updated, which is the cheapest tiebreak available. |
| The comparison chart somebody sent does not match either vendor's site | Vendors publish figures for their competitors. ZoomInfo's own site gives Apollo 270M contacts and 70M companies while Apollo publishes 240M and 30M. | Quote a vendor only about itself, and run your own 500 rows. A number nobody will stand behind in their own documentation is not a number to buy on. |

## What breaks, from the vendors' own docs

- **Apollo lists API enrichment as a paid feature.** Apollo's pricing page puts API Enrichment, Waterfall Enrichment, Automated CRM Enrichment and CRM Integrations in the Basic plan at $49 per seat per month on annual billing, with 30,000 credits per seat per year granted upfront. Professional is $79 per seat per month with 48,000, so the entry point for anything on this page is a paid seat.
- **Apollo rate limits move with the plan.** General endpoints are 50 a minute, 200 an hour and 600 a day on Free, rising to 200, 400 and 2,000 on Basic and Professional and 200, 600 and 6,000 on Organization. Search is 200 a minute, 6,000 an hour and 50,000 a day on the paid plans, and a 429 carries a retry-after header.
- **Apollo's waterfall requires a webhook.** Every waterfall request takes a valid webhook_url, and the synchronous response does not include phone numbers, so phone results arrive only at the webhook. Apollo also advises supplying at least a first and last name, a LinkedIn URL or an email for better match rates, which is the same dependence on an identifier the rest of this page is about.
- **What a waterfall miss costs is not a single number.** Apollo states that some data sources charge only when they return data and that others may consume credits for a lookup even when they find nothing, and that usage depends on the data requested, your plan, your team's configuration, the sources attempted and each source's pricing rules. That is honest and it means the cost of a miss is a property of your configuration rather than of the product.
- **Reverse Contact publishes one rule, with one exception.** Every 4xx and 5xx is 0 credits, a 404 depends on the endpoint, and Find Email and Find Phone are charged only when something is found. The exception is a live fetch, whose 2 credits are charged when the job is created and kept even when no profile is found, on every plan including Platform.
- **Unlimited has a daily ceiling of 100,000 profiles.** The covered calls cost nothing up to 100,000 profiles per workspace per UTC day, then return 429 DAILY_EXTRACTION_LIMIT_EXCEEDED until midnight UTC. The minute limit is 100 on Go, Plus and Max alike, so the plans buy unmetered endpoint families rather than throughput.
- **Neither coverage figure predicts your list.** Reverse Contact publishes 70%+ as a global identity match rate and says to measure your own on 500 rows. Apollo's documentation offers no match rate and instead tells you which identifiers improve one. Treat both as statements about a corpus rather than about your rows.

## The APIs, if you are building around it instead

### Reverse Contact

- **Base:** `https://api.reversecontact.com/v2`
- **Auth:** `Authorization: Bearer rc_your_api_key`. Keys are created in Workspace > API Keys.

| Call | Request | What it does |
|---|---|---|
| `POST /v2/enrich/persons` | `{ "email": "j.okafor@northwind.io" }` | Resolve a person from an email, a name plus company, or a profile URL. Cached resolution, returns in the response. |
| `POST /v2/enrich/companies` | `{ "domain": "northwind.io" }` | Resolve a company from a domain or a name. |
| `POST /v2/fetch/persons` | `{ "linkedInUrl": "..." }` | Standard profile lookup from the database. |
| `POST /v2/fetch/persons/live` | `{ "linkedInUrl": "..." }` | Live on-demand resolution. ASYNCHRONOUS: returns a webhookId to poll, not a record. |
| `POST /v2/search/people` | `{ "filters": { "currentCompanyDomain": "northwind.io" } }` | Filtered people search. 1 credit a profile delivered, and /v2/search/people/count is free. It replaced /v2/search/persons, which returns 410 Gone since 13 October 2026. |
| `POST /v2/search/organizations` | `{ "filters": { "companyDomain": "northwind.io" } }` | Filtered company search. A domain can also go straight to a company through POST /v2/enrich/companies, or through the enrich_company MCP tool since November 2026. |
| `POST /v2/contact/email` | `{ "linkedInUrl": "..." }` | Find an email. ASYNCHRONOUS: returns a taskId to poll. 3 credits for a professional address, 5 for a personal one, 8 for both, refunded when neither is found. |
| `GET /v2/webhooks/:webhookId` | - | Poll an async job until status is "succeeded". Polling is free and does not count against the rate limit. |

Response shape:

```json
{
  "success": true,
  "data": {
    "person": {
      "fullName": "Jane Okafor",
      "headline": "VP Sales at Northwind",
      "location": "London, United Kingdom",
      "linkedInUrl": "https://linkedin.com/in/...",
      "currentPosition": { "title": "VP Sales", "companyName": "Northwind", "startDate": "2023-04" },
      "emails": [], "experience": [], "education": [], "skills": []
    },
    "company": { "name": "Northwind", "domain": "northwind.io",
                 "industry": "Software Development", "employeeCount": 220 }
  },
  "error": null,
  "metadata": { "requestId": "req_...", "executionTimeMs": 480, "updatedAt": "2026-09-01T..." },
  "quotas": { "creditsConsumed": 1, "workspace": { "credits": { "total": 10000, "used": 4521, "left": 5479 } } }
}
```

**Rules that will cost you time if you skip them:**

- A miss returns **null**, not a best guess. Every response carries a confidence score, and you can raise the precision threshold on the request. Branch on it: do not treat a low-confidence answer as a match.
- Use the cached endpoints anywhere that must answer inside one HTTP request. The `/live` endpoints return a task and need polling.
- `quotas.workspace.credits.left` is on every response. Log it, or you will find out about the balance from a 402.
- Credit costs per call are published and a dollar rate per lookup is not: 2 credits for a reverse lookup from an email, 1 for a cached profile lookup, 2 for a live refresh, 3 for a business email and 20 for a direct phone number, with the last two charged only when one is found. Checks and the search count endpoint are free. Credit packs expire after 3 months. Do not hard-code a dollar cost assumption.

**MCP server:** `https://api.reversecontact.com/mcp`

- Auth: OAuth 2.1 where the client supports it, otherwise `Authorization: Bearer rc_your_api_key`.
- Tools: `enrich_person`, `enrich_person_live`, `enrich_company`, `enrich_company_live`, `search_persons`, `search_companies`, `check_usage`, `check_task`
- Streamable HTTP, JSON-RPC 2.0. The `_live` tools return a task id that `check_task` polls.

Docs: https://docs.reversecontact.com/getting-started

## Sources

- Apollo API: rate limits: https://docs.apollo.io/reference/rate-limits
- Apollo: enrich phone and email using the data waterfall: https://docs.apollo.io/docs/enrich-phone-and-email-using-data-waterfall
- Apollo: people enrichment endpoint: https://docs.apollo.io/reference/people-enrichment
- Apollo API pricing: https://docs.apollo.io/docs/api-pricing
- Apollo pricing and plan features: https://www.apollo.io/pricing
- ZoomInfo: published coverage figures: https://www.zoominfo.com/about
- Reverse Contact API documentation: https://docs.reversecontact.com/getting-started
- Reverse Contact: credits: https://docs.reversecontact.com/guides/credits
- Reverse Contact: rate limits: https://docs.reversecontact.com/guides/rate-limits
- Reverse Contact pricing: https://www.reversecontact.com/pricing
- 14 practitioner threads read on 2026-10-28, summarised on the page: https://www.reversecontact.com/integrations-hub/apollo-integrations/apollo-reverse-contact-integration#reddit
- This pair, with the reasoning behind each step: https://www.reversecontact.com/integrations-hub/apollo-integrations/apollo-reverse-contact-integration

---

*Published by Reverse Contact, which appears in this directory as a data provider.
No other vendor pays for placement. Where a vendor publishes no public figure, this file says so
rather than estimating. Reverse Contact costs are stated in credits, which it publishes; no dollar
rate per lookup appears here, because none is published and dividing a pack price is not their number.*
