---
name: salesforce-outreach-integration
description: Connect Salesforce and Outreach: 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 Salesforce and Outreach together, or asks why data is not moving between them.
---

# Salesforce and Outreach

> Generated from https://www.reversecontact.com/integrations-hub/salesforce-integrations/salesforce-outreach-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:** An Outreach contract, a Salesforce edition with REST API calls, and a Salesforce admin

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

## The short version

This is the integration Outreach was built around, and it shows: per-object polling, per-field outbound toggles, conditions on what pushes and manual stage mapping. It is also the one project on this site where the connector is the easy part. The edition question comes first and is absolute, because Essentials has no REST API access even with an add-on and Professional has to buy the Web API package, and behind it sit the permissions, the sandbox and the admin's change window. Budget days rather than hours, and spend the first of them on the API allocation rather than on field mapping.

## Which Salesforce edition carries this

Rows: Salesforce edition. Columns: Outreach contract. Outreach sets no tier of its own on the integration, so the grid has one column. The Salesforce side decides everything, and it decides it on API access rather than on features.

| Salesforce edition | Any Outreach contract |
|---|---|
| Essentials | Not possible |
| Professional | Needs the API package |
| Enterprise or Unlimited | REST API included |

- **Not possible.** Outreach states that Essentials does not support REST API access even with an add-on. There is no configuration and no purchase that makes this work.
- **Needs the API package.** Professional requires the Web API package and purchased API call bundles. Price those before you price the seats, because the call volume below is what you will be buying against.
- **REST API included.** REST API is included, and the only remaining question is your daily allocation against everything else connected to the org.

Counted off that grid, of three pairings: one gives you not possible, one gives you needs the API package, one gives you REST API included.

The top row is the one worth saying out loud in a procurement meeting: on Essentials this integration cannot be bought at any price, which is unusual enough that people assume it is a configuration problem.

## What actually syncs

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

| What | Direction | What that means in practice |
|---|---|---|
| Leads, contacts and accounts | Two-way sync | Salesforce is the source of truth for creation. Updates run both ways, with outbound update enabled only on the fields you choose. |
| Opportunities | Two-way sync | Bidirectional where in-line editing is on. Without it, Outreach recommends every push and outbound toggle off, so updates happen in Salesforce only. |
| Opportunity contact roles | Two-way sync | Including outbound delete, which few integrations in this directory will do at all. |
| Tasks, calls and emails | One way, out | Always one way, Outreach into Salesforce. Outreach recommends conditions so only completed or delivered activity pushes. |
| Events | One way, out | One way, which is why polling does nothing for them. Condition them or a connected calendar pushes historical internal meetings. |
| Users | One way, in | Updates in only, with polling off. Polling here imports every CRM user, and a user cannot be deleted afterwards. |

## Which field lands where

Mapping is explicit and per object, and the behaviour that matters is not where a field lands but what happens when both systems change it at once.

| In Salesforce | In Outreach | What to know about the match |
|---|---|---|
| Accounts, contacts, leads, opportunities | The Outreach equivalents | Create, read and edit, bounded by the integration user's profile and field-level security. |
| A field changed on both sides at once | A field-by-field merge | Outreach scans the record field by field rather than taking a row lock or letting one system win wholesale. |
| Completed activity in Outreach | Salesforce, in near real time | Usually visible in 30 to 45 seconds, slower during a high-volume force sync. |
| New and updated Salesforce records | Outreach, in bulk | Polling detects up to 2,000 changed records in one API call and imports 200 per call after that, which is a Salesforce limit rather than an Outreach choice. |
| The whole sync configuration | An exportable file | Importable into another environment, which is the supported route from sandbox to production. |

**What does not cross:**

- Anything the integration user cannot see. Field-level security on that profile is the ceiling for the entire plugin.
- Anything historic. Nothing backfills, so the go-live date is a decision rather than a detail.
- Any object on Salesforce Essentials, which has no REST API access even with an add-on.

## Connect it, in this order

**Who has to do it:** A Salesforce administrator, connecting as a dedicated integration user rather than as themselves.
**How long:** A day to connect and map. Longer if nobody has agreed which fields Outreach is allowed to own.

### 1. Confirm the Salesforce edition has REST API calls

*Where:* Salesforce Setup: Company Information, Organization Edition

Outreach is explicit: Enterprise and Unlimited include REST API; Professional needs the Web API package and purchased API call bundles; Essentials does not support REST API access even with an add-on. The last one ends the project rather than delaying it.

### 2. Build the integration user before you connect anything

*Where:* Salesforce: profile and user

That profile needs create, read and edit on every object Outreach will show, including accounts, contacts, leads, opportunities and user roles, field-level security that permits viewing and modifying every mapped field, and API Enabled under System Permissions. The last one is the single most common thing missing.

### 3. Connect with administrator credentials

*Where:* Outreach: the Salesforce plugin

Outreach lists admin credentials as a common connection error for a reason. Connect to the sandbox or production deliberately, and know which you are on before you start mapping.

### 4. Set the API call budget before the first full sync

*Where:* The plugin: Limits

An admin can cap how many calls Outreach may make per day. Outreach recommends setting global usage to 70 to 80 per cent of your total allocation, which leaves room for every other integration drawing on the same org.

### 5. Map objects and fields, and decide who owns each one

*Where:* The plugin: Object Setup, Set Field Mapping

This is the bulk of the work and the part that decides whether reps trust either system. Conflict resolution scans field by field rather than locking a row, so a field both sides write to will flip rather than fail, which is harder to notice.

### 6. Export the configuration once it works

*Where:* The plugin: the three dots, Export CRM Sync Configuration

Outreach supports exporting and importing the sync configuration, which is how you move a validated setup from sandbox to production and how you recover one after a sandbox refresh. Doing it at the end of a good day is cheaper than rebuilding it after a bad one.

The order protects two things that are expensive to retrofit: the integration user, which decides what the plugin can ever see, and the API budget, which decides whether it takes the org down with it.

## How to check it worked

- Create a record in Salesforce and watch it arrive. Inbound is a bulk poll, so minutes is normal.
- Complete a task in Outreach and watch it land in Salesforce. Outreach documents 30 to 45 seconds for outbound, so this one should feel immediate.
- Check the Outreach-specific API usage figure against your Salesforce allocation after a full day, not after an hour.
- Open Activity, filter on System Update, Plugins, Plugin Sync Error, and confirm the list is empty. That filter is where failures surface, not the record itself.

## 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 connection refuses admin credentials | Outreach lists this first among connection errors: the credentials used must be a Salesforce administrator, for sandbox and production alike. | Connect with an admin account, ideally the dedicated integration user rather than a person. |
| The connection drops every day or two | Salesforce session timeout settings, which Outreach calls out specifically for sandboxes breaking every 24 to 48 hours. | Check the session timeout in Salesforce rather than reconnecting repeatedly, which treats the symptom. |
| Records sync for some users and not others | Incorrect user mappings, one of the five errors Outreach lists as common, alongside unmapped lead queues. | Open the plugin logs, which export the last 10,000 errors, and fix the mappings rather than the records. |
| Writes fail with no obvious pattern | Validation errors or required fields missing on the Salesforce side, which the plugin surfaces rather than the record does. | Filter Activity by System Update, Plugins, Plugin Sync Error. The failures are there and nowhere else. |
| A field keeps changing back | Both systems are writing it. Conflict resolution merges field by field, so the last writer wins quietly rather than erroring. | Decide an owner for that field and stop one side writing it. Nothing in the plugin will flag the fight. |
| The org ran out of API calls overnight | An unbounded Outreach budget against a shared allocation, often triggered by a bulk change in Salesforce that the poll then imported 200 records at a time. | Set the limit to 70 to 80 per cent of total as Outreach recommends, and treat large Salesforce updates as API events in their own right. |

## What breaks, from the vendors' own docs

- **Essentials cannot run this, at any price.** Outreach documents that Enterprise and Unlimited include the REST API calls the sync needs, that Professional requires the Web API Package and API Call Bundles, and that Essential has no REST API access even with an add-on. Confirm the edition in Setup, Company Information before anything else, and ask your Salesforce representative rather than reading API usage statistics, because usage figures do not reveal whether the package was purchased.
- **Polling Users is a one-way door.** Outreach recommends leaving polling off for the User object, because polling imports every user in the CRM and a user cannot subsequently be deleted from Outreach. The same advice applies to Leads until setup is complete. This is the clearest example on the pair of a default that is cheap to get right and expensive to undo.
- **The API allocation is a budget you have to set.** Outreach advises setting the global API limit to 70 to 80 percent of your total calls and the Outreach-specific limit to 20 to 30 percent, and notifies admins as the limit approaches. When the limit is reached, syncing stops, and the window is a rolling 24 hours rather than a daily reset at midnight. Salesforce allocates 100,000 calls plus 1,000 per Salesforce licence on Enterprise, shared with every other integration in the org.
- **Nothing backfills, and conflicts resolve per field.** Only new and updated records move during polling, so history needs a separate import and your switch-on date is the start of the record. Conflicts are resolved field by field rather than by a winning system, which means the governance question is per field too: decide which side owns each one before you enable an outbound toggle, because the connector will implement whatever you hand it.

## 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

- Outreach support: Salesforce configuration for Outreach, end to end guide: https://support.outreach.io/support/solutions/articles/159000426522
- Outreach support: Outreach and CRM connection overview: https://support.outreach.io/support/solutions/articles/159000426014
- 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/salesforce-integrations/salesforce-outreach-integration#reddit
- This pair, with the reasoning behind each step: https://www.reversecontact.com/integrations-hub/salesforce-integrations/salesforce-outreach-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.*
