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

# Apollo and Salesforce

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

**What you have to buy first:** Apollo Basic or above, a Salesforce edition with API access, and a Salesforce admin

**What moves:** contacts, companies, deals, activities, both ways.
**How it is built:** native, marketplace app. **Effort:** hours.

## The short version

The deepest engagement-to-CRM sync in the directory, and the one with the most self-starting behaviour. Apollo pushes contacts, accounts, deals and activity into Salesforce in real time once enabled, with per-object settings and field mapping you control. Three documented behaviours decide whether the first month is calm: the configuration window is six hours and then syncing enables itself, push settings govern only net new contacts because updates to existing ones push regardless, and pushing any contact creates its account whether or not you asked, because Salesforce requires one.

## What the lead-or-contact switch actually changes

Rows: How the record was pushed before. Columns: What you set the push type to now. The plan requirements here are short: a paid Apollo plan, because the free one excludes CRM integrations, and a Salesforce edition with API access. The decision that costs real money is a switch rather than a tier, and this is what it does.

| How the record was pushed before | Leads | Contacts |
|---|---|---|
| Already pushed as a lead | updated as a lead | updated as a lead |
| Already pushed as a contact | updated as a contact | updated as a contact |
| Never pushed | updated as a lead | updated as a contact |

- **updated as a lead.** Apollo keeps updating existing lead records as leads. It does not convert them and does not create a duplicate contact alongside them.
- **updated as a contact.** Apollo keeps updating existing contact records as contacts, and will not turn one back into a lead. Salesforce does not support that direction either.

Counted off that grid, of six pairings: three give you updated as a lead, three give you updated as a contact.

Two of the three rows read the same across both columns, and that is the finding: the switch governs records that have never been pushed and nothing else. Flipping it on a live integration leaves you running two record types at once, with lead conversion in Salesforce as the only way back and no way back from contacts at all.

## 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 |
|---|---|---|
| Contacts and leads | One way, out | Net new contacts push on save, with field mapping you configure. Updates to existing contacts push automatically whatever the push settings say. |
| Accounts | One way, out | Created or updated whenever a contact is pushed, even with Push accounts off, because Salesforce requires every contact to link to an account. |
| Deals | Two-way sync | Full bidirectional, or pull-only, or push-only. With bidirectional on, Salesforce is the source of truth for deals that have already synced. |
| Activities | One way, out | Emails, tasks, notes, meeting summaries and phone calls, each configured separately so you choose what reaches the CRM. |
| Salesforce records into Apollo | One way, in | Pull settings bring records back, and can infer accounts where your org works in leads. |
| Custom objects | One way, in | Read only. Organization plans can configure up to ten, and the data cannot trigger Apollo workflows. |

## Which field lands where

There are five objects to configure and the settings on them are not symmetrical. Two of the five behave differently from how their own switch reads, which is the whole reason this section exists rather than pointing at the mapping screen.

| In Apollo | In Salesforce | What to know about the match |
|---|---|---|
| Contacts | Salesforce contacts or leads, your choice | Push based on certain stages is available here and only here. A contact with no stage is not pushed unless you explicitly include No stage in the selection. |
| Leads | Salesforce leads | If your org works in leads, contacts associate with leads rather than accounts. Apollo can infer accounts for you in the pull settings instead. |
| Accounts | Salesforce accounts, whether or not you asked | Pushing a net new contact creates or updates its account even with Push accounts off, because Salesforce will not accept a contact without one. |
| Deals | Salesforce opportunities | Bidirectional, pull-only or push-only. With bidirectional on, Salesforce is the source of truth for deals that have already synced. |
| Activities | Five separate settings | Emails, tasks, notes, meeting summaries and phone calls, configured one at a time. This is the object where a duplicate-logging problem is prevented rather than fixed. |
| The source field | Defaults to Apollo | Set on new contacts synced from Apollo, and if the field you pick is a picklist you choose the value too. Worth setting deliberately, because it is the only attribution this integration writes. |
| Unverified emails | Off unless you tick it | Push unverified emails for contacts and leads governs the email address only, not whether the contact is pushed. A contact with an unverified email still arrives; the address does not. |
| Custom objects | Read only, up to ten on Organization plans | They come into Apollo and cannot trigger Apollo workflows, so they are context for a rep rather than something to automate on. |

### What the push settings actually govern

| The action | How it reads on the record |
|---|---|
| A net new contact saved in Apollo | Governed by the push setting and the stage filter |
| A contact imported from a CSV | Governed the same way |
| An update to a contact already in Salesforce | Pushed automatically, regardless of push settings |
| A record you push by hand | Overrides every sync setting, including stage restrictions |
| The account behind any pushed contact | Created or updated regardless, because Salesforce requires one |
| Anything, during the initial data pull | Manual push appears but does not work until the pull completes |

**What does not cross:**

- Filtering beyond stage. Apollo states that Salesforce push settings do not support filtering on anything else, so there is no way to push only contacts whose custom field has a particular value.
- A lead-to-contact conversion. Changing the push type affects new records only, and converting existing leads is Salesforce's own lead conversion process rather than an Apollo setting.
- The Owner field, in the usual case. Records created through the team sync connection normally carry the integration user, and Apollo's documented alternative is mapping its created_by field to Salesforce CreatedById instead.

## Connect it, in this order

**Who has to do it:** A Salesforce admin to install the managed package, and an Apollo user with permission to edit CRM integrations. The two are rarely the same person.
**How long:** An hour of clicks, and the six hours after it are not optional free time.

### 1. Clear the configuration afternoon before you connect anything

*Where:* Your calendar

On a paid Apollo plan the clock starts at the connection: six hours to set the field mapping and the inbound and outbound settings, after which syncing enables itself. You cannot manually pull records during the window, so there is no way to use the time for anything but configuration.

### 2. Decide production or sandbox, because you get one

*Where:* Apollo: Settings, Integrations, Salesforce

Connect for production, or Connect to Sandbox, and never both at once. A team that rehearses in a sandbox has to disconnect it before going live, which means doing the configuration twice unless the rehearsal was the point.

### 3. Install the Apollo managed package for the right users

*Where:* Salesforce AppExchange, via Apollo

Click Install Managed Package in Apollo, which redirects you to the AppExchange. Apollo strongly recommends installing for all users, or for the specific profiles that contain your Apollo users. Installation takes a few minutes and needs Salesforce admin access.

### 4. Create the integration user in the Apollo Setup app

*Where:* Salesforce: App Launcher, Apollo Setup

Open the Apollo Setup app, click Get Started, and create a new integration user or select an existing one. Apollo strongly recommends keeping every default permission selected to prevent sync issues, and warns that mapping custom Salesforce fields later requires giving this user access to those fields now.

### 5. Authenticate from Apollo as that user

*Where:* Apollo: Connect, Yes Continue

Whoever connects using the dedicated integration user becomes the team sync user, and that one connection does the account-wide syncing. Individual Apollo users do not need to connect their own Salesforce accounts for standard data sync.

### 6. Set the push type knowing it is close to permanent

*Where:* Apollo: Salesforce, Contacts, Sync

Leads or contacts, and the choice only governs records that have never been pushed. Existing leads stay leads and keep being updated as leads; existing contacts stay contacts. Salesforce can convert a lead to a contact and cannot convert one back.

### 7. Configure each activity type separately

*Where:* Apollo: Activities, Sync

Emails, tasks, notes, meeting summaries and phone calls are five settings rather than one switch. If something else in the org already logs emails or calls, this is where you keep Apollo out of that lane.

### 8. Run a manual Push all after any mapping change

*Where:* Apollo: people or company search

Apollo documents that a manual push overrides the sync settings entirely, ignoring stage restrictions and other limits, and that a Push all is how you apply a new field or stage mapping to records already in Salesforce. Manual push also does not work during the initial data pull.

The first two steps are scheduling decisions and they are the ones that go wrong, because the clock and the single-org rule both punish a team that connects to have a look. Everything after that is reversible except the lead-or-contact choice, which the grid below is about, and which the [CRM layer](layer:crm) answers differently in every org.

## How to check it worked

- Check the clock the moment you connect. If the six hours expire mid-configuration, syncing starts against whatever the mapping looked like at that minute, and the first sync is the one that touches every matched record.
- Push one net new contact whose account does not exist in Salesforce, with Push accounts switched off. The account will be created anyway, and seeing it happen once is cheaper than explaining it later.
- Switch push off and then change a contact that already exists in Apollo. It will still reach Salesforce, because push settings only govern net new and CSV-imported records.
- Check the Owner field on a record Apollo created. Records created through the team sync connection normally carry the integration user, so a team that routes on Owner needs to decide what to do about that before go-live.

## 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 |
|---|---|---|
| Insufficient access on cross reference ID | The integration user cannot see a record that the one being written relates to through a lookup or master-detail field. It is a record sharing problem rather than an object or field permission. | Check the sharing model and the lookup fields for the integration user, not for yourself. Practitioners in r/salesforce point out that being an admin does not guarantee read and edit access to every field, which is why the error survives an admin credential. |
| Syncing started before the mapping was finished | The six hour configuration window expired. On a paid plan Apollo enables syncing automatically at that point, whether or not anybody was ready. | Fix the mapping and run a manual Push all, which Apollo documents as the way to apply a new field or stage mapping to records already in Salesforce. The first sync cannot be unwound. |
| Apollo is still writing after push was switched off | Push settings govern net new contacts saved in Apollo and ones imported from a CSV. Updates to contacts that already exist push automatically regardless. | Control the field mapping rather than the push toggle. A field Apollo must never write is a field Apollo must not be mapped to. |
| A contact landed on the wrong account | The contact matched more than one existing Salesforce account, and Apollo documents assigning one at random in that case. | Use consistent account naming, or push only contacts whose accounts already exist. There is no tie-break setting to configure. |
| Accounts are appearing that nobody pushed | Pushing a net new contact creates or updates its linked account even with Push accounts off, because Salesforce requires every contact to have one. | Treat it as a governance conversation rather than a setting. In an org where account creation is controlled, have it before go-live rather than with whoever owns data quality afterwards. |
| Contacts with no stage are not reaching Salesforce | Push based on certain stages excludes contacts with no stage unless No stage is explicitly selected in the list. | Add No stage to the selection, or push everything. Remember that stage is the only filter available: Apollo states push settings do not support filtering on custom field values. |
| A sync error survived upgrading the Salesforce edition | An edition with API access is necessary and not sufficient. The same error is produced by the connected user's permissions and by an Apollo field mapping, and one r/salesforce commenter reports legacy Group Edition blocking API integrations whatever you pay. | Confirm which of the three it is before buying the upgrade. Practitioners in that thread say exactly this, and a field mapping or a sharing rule will keep failing after the plan changes. |
| The migrate option for the managed package is not there | Apollo is rolling the upgrade path out over time. Existing connections have until 31 December 2026 and the option appears when Apollo says it is ready. | Wait for the email rather than reconnecting from scratch. The upgrade preserves existing field mappings and push and pull settings, and a fresh connection would restart the six hour window. |

## What breaks, from the vendors' own docs

- **The configuration window closes by itself.** Six hours after you first connect on a paid plan, syncing enables automatically whether or not the field mapping is finished, and you cannot manually pull records until it does. Book the configuration session for immediately after the connection rather than for the following morning, because the integration does not wait and the first sync is the one that writes to every matched record.
- **Push settings do not govern updates.** They apply to net new contacts saved in Apollo or imported by CSV. Every update to a contact that already exists pushes automatically regardless. Teams who switch push off expecting Apollo to go quiet find it still writing, and the only real control over a given field is the mapping.
- **Accounts are created whether you asked or not.** Pushing a net new contact creates or updates its linked account even with Push accounts off, because Salesforce will not accept a contact without one. In an org where account creation is governed, that is a process conversation to have before go-live rather than a surprise for whoever owns data quality.
- **One org at a time, and not the free plan.** You can connect a production org or a sandbox, never both, so rehearsing in a sandbox means disconnecting it before you go live. Apollo's free plan excludes CRM integrations entirely, which makes Basic the real floor for anything on this page.
- **Existing connections have a deadline.** Apollo states that all existing Salesforce connections must upgrade to the managed package by 31 December 2026, and recommends doing it early. The upgrade keeps your field mappings and push and pull settings, and the migrate option is being rolled out gradually, so a team that cannot see it yet is waiting for an email from Apollo rather than looking in the wrong place.

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

### Salesforce

- **Base:** `https://{instance}.my.salesforce.com/services/data/v60.0`
- **Auth:** OAuth 2.0 through a connected app. **API access is an edition feature**: editions without it cannot run any of this.

| Call | Request | What it does |
|---|---|---|
| `PATCH /sobjects/Contact/{id}` | `{ "RC_Title__c": "VP Sales" }` | Update a record. Custom fields carry the __c suffix. |
| `POST /composite/sobjects` | `{ "allOrNone": false, "records": [...] }` | Batch up to 200. `allOrNone: false` so one bad row does not roll back the batch. |
| `GET /query?q=SELECT+Id,Email+FROM+Contact+WHERE+Title=null` | - | SOQL for the filtered slice. |

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

- **Validation rules, required fields, duplicate rules and Apex triggers all apply to your writes.** A completed run is not a successful write. Read the per-record errors.
- **The daily API allocation is shared across the whole org**, set by edition and licence count. A row-by-row job competes with every other integration; the symptom of exhausting it is other people's integrations failing.
- Test in a sandbox with ten records before production. The rules you will hit were written years ago by somebody who has left.
- Installing anything usually needs Modify Metadata, Download AppExchange Packages and Customize Application. That is an admin on their own schedule.

Docs: https://developer.salesforce.com/docs/apis

## Filling the record this integration moves

The integration above moves a record between two systems. Neither of them creates what is in it, so a sync that works perfectly still carries whatever gaps the record arrived with. Reverse Contact resolves an email, a domain or a profile URL into a verified people and company record through one API, and returns null with a confidence score rather than a guess.

### 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 knowledge base: integrate Salesforce with Apollo: https://knowledge.apollo.io/hc/en-us/articles/4414356051725-Integrate-Salesforce-with-Apollo
- Apollo knowledge base: configure Salesforce push settings: https://knowledge.apollo.io/hc/en-us/articles/4414469523981-Configure-Salesforce-Push-Settings
- Salesforce developer limits and allocations quick reference (PDF): https://resources.docs.salesforce.com/latest/latest/en-us/sfdc/pdf/salesforce_app_limits_cheatsheet.pdf
- 14 practitioner threads read on 2026-10-11, summarised on the page: https://www.reversecontact.com/integrations-hub/apollo-integrations/apollo-salesforce-integration#reddit
- This pair, with the reasoning behind each step: https://www.reversecontact.com/integrations-hub/apollo-integrations/apollo-salesforce-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.*
