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

# Outreach and Zapier

> Generated from https://www.reversecontact.com/integrations-hub/outreach-integrations/outreach-zapier-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 Outreach contract, an Outreach account that can authorise the app, and a Zapier plan sized to your task volume

**What moves:** contacts, companies, deals, tasks, activities, both ways.
**How it is built:** zapier, make or n8n, marketplace app. **Effort:** minutes.

## The short version

The best-equipped app on the Zapier hub, and the only one here that can start a Zap on more than one kind of event. Five of its six triggers are instant, the actions cover the whole prospect lifecycle from create to sequence enrolment, and there is a beta raw API Request for anything the four named actions do not reach. The two things to design around are that the one trigger you want for closed-loop reporting is the only one that polls, and that enrolment has no idempotency: nothing stops a Zap adding the same person to the same sequence twice.

## Which Outreach events start a Zap, and how fast

Rows: Outreach event. Columns: How it reaches Zapier. Not an editions grid, because no plan on either side decides whether this pair works: Outreach needs a contract and Zapier needs enough tasks. The question that changes a build is which events are instant and which are not, and the answer is uneven in a way the app listing does not make obvious.

| Outreach event | Starts a Zap instantly | Polls for changes | Needs a Sequence ID first |
|---|---|---|---|
| New Prospect | Yes | No | No |
| New Call | Yes | No | No |
| Updated Account | Yes | No | No |
| Updated Opportunity | Yes | No | No |
| Updated Task | Yes | No | No |
| Completed Sequence Task | No | Yes | Yes |

- **Yes.** Taken from Zapier's own listing for the Outreach app, which marks each trigger as Instant or as Polling and names the required fields.
- **No.** Not that behaviour. A polling trigger is checked every 15 minutes on the Free plan, which Zapier states on the trigger itself.

Counted off that grid, of eighteen pairings: seven give you yes, eleven give you no.

Five rows read identically and the sixth is the whole point. Completed Sequence Task is the event most teams want, because it is the one that closes the loop on whether the sequence did anything, and it is the only one that is neither instant nor global: it polls, and it watches a single sequence you have to name when you build the Zap.

## What actually syncs

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

| What | Direction | What that means in practice |
|---|---|---|
| New prospects | One way, out | New Prospect fires instantly when a prospect is created, which makes Outreach a usable starting point for a chain rather than only a destination. |
| Calls and task updates | One way, out | New Call and Updated Task both fire instantly. These are the activity events, and they are what a CRM or a warehouse wants if it is keeping its own record of what the team did. |
| Account and opportunity changes | One way, out | Updated Account and Updated Opportunity fire instantly. Note the asymmetry: there is no trigger for a new account or a new opportunity, only for updates to one. |
| Completed sequence tasks | One way, out | The one polling trigger, checked every 15 minutes on the free plan, and the only one that requires a Sequence ID up front. It watches the sequence you name rather than all of them. |
| New prospects, written back | One way, in | Create Prospect takes first and last name, email addresses, and the account, opportunity, stage, persona and owner ids. The ids are the hard part: they are Outreach ids rather than names. |
| Sequence enrolment | One way, in | Add Prospect to Sequence, usually preceded by Find Sequence to resolve the sequence by name. This is the action the pair exists for and the one with no duplicate protection. |
| Anything else | One way, in | API Request is a beta action making a raw HTTP call that carries the integration's authentication, so the whole Outreach API is reachable without building an OAuth app of your own. |

## Which field lands where

The thing that decides how you wire this is which identifier each action needs, and the answer is almost always an Outreach id rather than a name. Only one action resolves a name for you, and it resolves sequences.

| In Outreach | In Zapier | What to know about the match |
|---|---|---|
| Create Prospect | A new Outreach prospect | First Name, Last Name and Email Addresses, plus Account ID, Opportunity IDs, Stage ID, Persona ID and Owner ID. Every one of those ids has to come from somewhere else in the Zap. |
| Find Sequence | A sequence, by name or id | The only search action, and the only place a human-readable name is resolved for you. Put it before any enrolment step. |
| Add Prospect to Sequence | An enrolment | Takes the prospect and the sequence. No duplicate check, so running it twice enrols twice. |
| API Request (Beta) | Any Outreach endpoint | A raw HTTP request carrying the integration's authentication. Beta, and the escape hatch when the four named actions do not cover the job. |
| New Prospect, New Call, Updated Task | A Zap, instantly | The instant triggers, carrying the Outreach record that changed. These are what let Outreach begin a chain rather than only receive one. |
| Completed Sequence Task | A Zap, within 15 minutes | Polling rather than instant, and scoped to one Sequence ID. The free plan checks every 15 minutes. |

**What does not cross:**

- A new account or a new opportunity. Only the updated versions have triggers, so a first appearance has to be inferred.
- Any duplicate protection on enrolment. Nothing in the integration knows whether a prospect is already in the sequence.
- Sequence creation. Find Sequence reads sequences and nothing here writes one, so the sequence is always built in Outreach first.
- The reply or the outcome. These triggers carry records and task completion rather than what a prospect said back, which stays in Outreach.

## Connect it, in this order

**Who has to do it:** Somebody with an Outreach account that can authorise the app, plus whoever owns the Zapier workspace. Ideally create a dedicated Outreach user for it first.
**How long:** Twenty minutes for the first Zap, most of it finding the ids the write actions want.

### 1. Decide which Outreach user this connects as

*Where:* Outreach: users

The rate limit is 10,000 requests an hour metered per user, so the account you authenticate with determines whose budget a bulk run spends. A dedicated service user is the right answer and it is much easier to do now than to change once Zaps depend on it.

### 2. Connect Outreach in Zapier

*Where:* Zapier: the Outreach app

Add the Outreach app and authenticate as that user. Outreach uses OAuth 2.0, so this is a browser consent rather than a key you paste, and the person completing it needs an Outreach account with the rights to authorise an application.

### 3. Pick the trigger, knowing which one polls

*Where:* Zapier: trigger

New Prospect, New Call, Updated Account, Updated Opportunity and Updated Task are all instant. Completed Sequence Task polls, every 15 minutes on the free plan, and asks for a Sequence ID. Choose deliberately: the polling one is often the one people want and it behaves differently from the rest.

### 4. Resolve the sequence by name rather than by id

*Where:* Zapier: Find Sequence

Find Sequence takes a sequence name or an id and returns the sequence. Put it in front of the enrolment step so the Zap keeps working when somebody rebuilds a sequence, which changes the id and does not change the name.

### 5. Add your own duplicate check

*Where:* Zapier: a filter

Add Prospect to Sequence has no idempotency of its own. Put a filter or a lookup before it so a prospect already in the sequence is not added again. This is the step the integration cannot do for you and the one that stops somebody getting two first emails.

### 6. Reach for API Request only when the named actions do not fit

*Where:* Zapier: API Request (Beta)

The beta API Request action makes a raw HTTP call carrying the integration's authentication, so the rest of the Outreach API is available without building your own OAuth app. It is beta, so treat it as the escape hatch rather than the foundation.

Nothing is installed inside Outreach, so removing this is a Zapier action and an authorisation to revoke. What persists is every prospect the Zaps created and every enrolment they made, which is the usual asymmetry: the connection is reversible and the records are not.

## How to check it worked

- Create one prospect in Outreach and confirm the instant trigger fires in seconds rather than minutes. If it takes a quarter of an hour you have picked the polling trigger by mistake.
- Run the enrolment Zap twice on the same prospect and watch what happens. It should be stopped by your filter; if the person is enrolled twice, the guard is not working and it will not announce itself later.
- Check which Outreach user the connection authenticated as, in Outreach rather than in Zapier, because that is whose hourly allowance a backfill will spend.
- Count the tasks one prospect costs end to end. Two steps is the floor for enrolment, and the number only goes up once filters and lookups are added.

## 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 same prospect got two first-touch emails | Add Prospect to Sequence was run twice. The action has no duplicate protection and reports success both times. | Put a filter or a lookup in front of the enrolment step and make the Zap stop when the prospect is already enrolled. Nothing in the integration will do this, so it is a design step rather than a setting. |
| A Zap that enrols people stopped working after somebody edited the sequence | The Sequence ID was hard-coded and rebuilding a sequence changes it. | Use Find Sequence to resolve the sequence by name and feed its output into the enrolment step. The name survives a rebuild and the id does not. |
| The trigger takes a quarter of an hour to fire | It is Completed Sequence Task, the only polling trigger, which Zapier checks every 15 minutes on the Free plan. | Accept the delay or redesign around an instant trigger. The other five are instant, so if the latency matters more than the specific event, one of them is usually close enough. |
| Create Prospect fails on a missing or invalid id | The action takes Account ID, Opportunity IDs, Stage ID, Persona ID and Owner ID, and none of those accepts a name. | Resolve the ids earlier in the Zap, from the record that triggered it or from a lookup. Find Sequence only resolves sequences, so everything else has to arrive already as an id. |
| A bulk run exhausted somebody's Outreach allowance | Outreach meters 10,000 requests an hour per user, and the connection authenticated as a person rather than as a service account. | Reconnect as a dedicated Outreach user so the Zaps have their own budget. This is much easier before Zaps depend on the connection than after. |
| The Zapier bill is far higher than the number of Zaps suggests | The meter is per step. An enrolment is at least two steps, and a filter and a lookup make it four. | Count rows multiplied by steps rather than Zaps, and consider batching or an orchestrator billed differently if the arithmetic does not work. The Zapier hub page has the same warning for every pair on it. |

## What breaks, from the vendors' own docs

- **Only one trigger polls, and it is the one you want.** Five of the six triggers are instant. Completed Sequence Task is not: Zapier documents checking for new data every 15 minutes on the Free plan, and the trigger requires a Sequence ID, so it watches a single named sequence. That is the event most teams want for closed-loop reporting, which makes this the asymmetry to design around rather than discover.
- **Enrolment is not idempotent.** Nothing in Add Prospect to Sequence checks whether the prospect is already enrolled. Run the same Zap twice, or let two Zaps overlap, and the same person is added again. Outreach's other integrations warn about the same thing in different words, which is why the directory's Clay page says to check before you push: the guard is always yours to build.
- **The write actions want ids, not names.** Create Prospect takes Account ID, Opportunity IDs, Stage ID, Persona ID and Owner ID. None of those is a name you can type from memory, so a Zap that creates a prospect properly usually needs a lookup step first, and Find Sequence only resolves sequences.
- **The rate limit is per user, which is good news.** Outreach allows 10,000 requests an hour and meters them per user rather than per organisation, so a Zap authenticated as its own service user does not spend the reps' allowance. Outreach reserves the right to change it. Connect this as a dedicated user rather than as whoever happened to set it up.
- **The meter is per step.** Zapier charges a task per step rather than per Zap, so the Find Sequence plus Add Prospect to Sequence pattern costs two tasks per prospect before anything else in the chain. Over a list of a thousand that is two thousand tasks, which is the arithmetic that decides whether this belongs in Zapier or in something billed differently.
- **No trigger for a new account or opportunity.** Updated Account and Updated Opportunity exist; their created counterparts do not. If a Zap needs to fire when an account first appears, it has to infer it from an update or watch the other side of the relationship, which is a workaround rather than a configuration.

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

- Zapier: Outreach integrations, triggers and actions: https://zapier.com/apps/outreach/integrations
- Outreach: API getting started: https://developers.outreach.io/api/getting-started
- Zapier pricing: https://zapier.com/pricing
- 14 practitioner threads read on 2026-10-28, summarised on the page: https://www.reversecontact.com/integrations-hub/outreach-integrations/outreach-zapier-integration#reddit
- This pair, with the reasoning behind each step: https://www.reversecontact.com/integrations-hub/outreach-integrations/outreach-zapier-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.*
