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

# Pipedrive and Reverse Contact

> Generated from https://www.reversecontact.com/integrations-hub/reverse-contact-integrations/pipedrive-reverse-contact-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:** A Reverse Contact API key, a Pipedrive plan with automations, and somewhere outside Pipedrive to receive the webhook

**What moves:** contacts, companies, deals, one way, into Pipedrive.
**How it is built:** built on the api, zapier, make or n8n. **Effort:** hours.

## The short version

Pipedrive is the clearest case in this directory of a CRM whose automation builder looks like it can do the job and cannot quite. The webhook action exists, it is well documented and it fires on conditions you define, but the response goes nowhere, so an enrichment is always a round trip: webhook out, a worker in the middle, API call back in. Once you accept that, the build is small and the limits are generous. The mistake is designing for a one-step automation that was never possible.

## Which Pipedrive plan changes which part of this

Rows: Pipedrive plan. Columns: What you get. Three of these four columns move with the plan and the middle one does not. That column is the finding rather than a formatting accident: no Pipedrive plan at any price lets an automation read what its webhook returned, so the thing that decides this build is not a tier at all.

| Pipedrive plan | An automation with a webhook action | Reading what that webhook returned | Enriching from outside, through the API | Burst headroom for a backfill, per token |
|---|---|---|---|---|
| Lite, $14 a seat | No | No | Yes | No |
| Growth, $39 a seat | Yes | No | Yes | Workable |
| Premium, $59 a seat | Yes | No | Yes | Yes |
| Ultimate, $79 a seat | Yes | No | Yes | Yes |

- **Yes.** Available on that plan. Pipedrive sells automations from Growth on its current pricing card, and the API itself is on every plan, which is why the third column never moves: a worker outside the CRM can read and write records on Lite just as well as on Ultimate.
- **Workable.** Growth allows 40 requests per 2 seconds on an API token and 160 on an OAuth app, which is enough for a steady trickle and tight for a backfill. Premium and Ultimate raise that to 100 and 400, then 120 and 480.
- **No.** Not available at any volume on that line. Lite has no automations, so there is no webhook action to add, and the response column is no on every plan: the documented action takes a webhook, a method, a body and a path, and returns nothing a later step can read.

Counted off that grid, of sixteen pairings: nine give you yes, one gives you workable, six give you no.

So upgrading buys you a trigger and some burst headroom, and never buys you the thing the build actually needs. That is a different kind of gate from the one monday has, where every plan can be made to work and the daily call ceiling decides how many records a day you get, and a different kind again from HubSpot, where one separate hub decides everything.

## What actually syncs

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

| What | Direction | What that means in practice |
|---|---|---|
| Trigger | One way, out | An automation on person or organisation created, firing the webhook action to your endpoint. |
| The enrichment | One way, out | Your worker, a Zap or a Make scenario POSTs to /v2/enrich/persons with the email. 2 credits on a match, free on a check. |
| Write-back | One way, in | A PATCH to the Pipedrive API sets the custom fields. 10 tokens a record from the daily budget. |
| Anything back to Reverse Contact | One way, out | Nothing. This is a read layer, and the worker decides which Pipedrive fields may be written. |

## Which field lands where

Nothing here is a field mapping, because the enrichment does not happen in Pipedrive. What travels out is a body you compose, what comes back arrives through the API from outside, and the useful detail is what each half costs and what each half is allowed to do.

| In Pipedrive | In Reverse Contact | What to know about the match |
|---|---|---|
| The automation trigger | Nothing yet | A person or organisation created or updated, with whatever conditions you set. Pipedrive notes that automated webhooks can be triggered by all users regardless of their visibility permissions or admin status, which is worth knowing before a condition relies on ownership. |
| The webhook action: Webhook, Method, Body | POST to your worker | The three mandatory fields, plus a path appended to the webhook's base domain. Methods are POST, PUT or DELETE; there is no GET. The body is built with a key-value builder that offers the record's fields from a dropdown, or raw JSON for full control. |
| The response to that webhook | Discarded | This is the whole reason the pair has the shape it does. The documented action has a webhook, a method, a body and a path, and no output, so whatever Reverse Contact answers cannot reach a later step. |
| Your worker, holding the email | POST /v2/enrich/persons, 2 credits | Identity, the current role, history, education, skills and location on one schema. A miss returns null with a confidence score and costs nothing, because every 4xx and 5xx is free. |
| Your worker, holding a domain | POST /v2/enrich/companies, 2 credits | Firmographics from a domain or a company name. Run it on the organisation rather than once per person attached to it. |
| The write back in | PATCH a person or organisation, 10 tokens | Through the Pipedrive API with your own credential. Updating one entity costs 10 tokens and reading one costs 2, so the round trip is about 12 against a daily budget of 30,000 times the plan multiplier times seats. |
| A search, if you reach for one | 40 tokens, and 10 requests per 2 seconds | The most expensive endpoint on the budget and the only one with its own burst limit, which is identical on every plan and every authentication type. This is the call that turns a backfill into a queue. |
| Anything outbound to Reverse Contact | Only what your worker sends | Reverse Contact stores nothing back. The direction runs one way, and there is nothing in the product to write to. |

### What the round trip costs against the token budget

Pipedrive meters the API in tokens rather than calls, weighted by how heavy each endpoint is, and the budget is shared across every user and integration on the account. The arithmetic below is what decides whether a backfill is an evening or a fortnight.

| The call | What it costs |
|---|---|
| The daily budget itself | 30,000 base tokens times the plan multiplier times seats, plus any top-ups. Lite multiplies by 1, Growth by 2, Premium by 5, Ultimate by 7 |
| Reading one person or organisation | 2 tokens |
| Reading a list of them | 20 tokens, so a filtered list beats a loop of single reads |
| Updating one record with the enriched fields | 10 tokens |
| One full enrichment round trip | About 12 tokens, read plus update. The Reverse Contact call itself costs no tokens at all, because it is not a Pipedrive request |
| A search | 40 tokens, and capped at 10 requests every 2 seconds on every plan and every auth type |
| When the budget runs out | 429 until the reset, which is midnight in the server timezone and may not be your midnight |

**What does not cross:**

- The response to the webhook action. The documented inputs are a webhook, a method, a body and a path, and there is no output for a later step to read, which is why this build always has a worker in it.
- A GET from inside an automation. The method list is POST, PUT and DELETE, so the automation cannot fetch anything even in principle.
- The live endpoints. They answer with a task id and are documented as usually seconds and possibly tens of minutes, so they belong in the worker rather than anywhere near the automation.
- A business email or a direct phone number. Both are separate endpoints at 3 and 20 credits, charged only when one is found.

## Connect it, in this order

**Who has to do it:** A global admin, because creating an automation webhook is admin-only. Plus whoever runs the worker in the middle and whoever can create a Reverse Contact API key.
**How long:** Half a day, most of it standing the worker up. The Pipedrive half is twenty minutes once you accept the round trip.

### 1. Accept the round trip before you draw anything

*Where:* A whiteboard, not Pipedrive

The webhook action sends a body to a path and the documented fields are the webhook, the method and the body. Nothing hands the response to a later step, so the shape is always webhook out, worker in the middle, API call back in. Designing for a one-step automation is the mistake this page exists to prevent, and it is only discoverable after you have built the first half.

### 2. Decide where the worker lives, because that is the real build

*Where:* Zapier, Make, n8n or your own host

The native Zapier app can be the worker with no code and bills nothing when a lookup misses. An n8n instance keeps records on infrastructure you control and handles the live endpoints. Your own service is the cheapest at volume. This is the decision that determines who maintains the pair.

### 3. Create the fields the enrichment is allowed to own

*Where:* Pipedrive: Settings, Data fields

Custom fields, prefixed, separate from the ones a rep fills in. The write comes back through the API from outside the CRM, which means nothing in Pipedrive is standing between a bad mapping and a field somebody maintains by hand.

### 4. Create a dedicated automation webhook as a global admin

*Where:* Pipedrive: Settings, Webhooks, + Webhooks, Automation webhook

This action is global-admin only, and Pipedrive states that existing webhooks cannot be re-used for automations, so it has to be a new one of this specific type. If no automation webhook exists yet, the webhook action will not even appear in the automation builder.

### 5. End the endpoint URL with the right character

*Where:* Pipedrive: the webhook, endpoint URL

Pipedrive requires the endpoint URL to conclude with a slash, an ampersand, a question mark or an equals sign, to stop malformed URLs being assembled from a base domain and a path. It is the most specific and least guessable requirement on this page.

### 6. Pick a method from the three it offers

*Where:* Pipedrive: the webhook action, Method

POST, PUT or DELETE. There is no GET, which is a second reason the automation cannot fetch anything: it is built to send. Use POST and compose the body with the key-value builder or raw JSON, pulling the email straight off the record.

### 7. Build the write-back with the token budget in mind

*Where:* Your worker, against the Pipedrive API

The daily allowance is 30,000 base tokens times the plan multiplier times seats, and reading one record costs 2 tokens while updating one costs 10. So an enrichment round trip is about 12 tokens, and a search is 40 on its own, which is the call to avoid in a loop.

### 8. Respect the 429 rather than retrying through it

*Where:* Your worker, reading the response headers

Pipedrive publishes x-ratelimit-limit, x-ratelimit-remaining, x-ratelimit-reset and x-daily-requests-left on responses. Ignoring a 429 and keeping the volume up earns a 403 from Cloudflare as an HTML error page, which is a much worse failure than the one you were retrying past.

The first two steps are the build and the other six are configuration. That is the opposite of [the Attio version](pair:attio+reverse-contact), where the whole thing is eight blocks in one workflow, and the difference is one documented sentence about whether a response can be read.

## How to check it worked

- Fire the automation once at a request bin rather than at your worker, and read the execution history. It shows the final body and path, which is the only place to confirm the record fields interpolated the way you expected.
- Point the webhook at a URL that returns a 500 on purpose. Pipedrive states that a webhook which is not working or is missing authentication fails the automation execution, so you should see the automation fail rather than carry on quietly.
- Run the worker on an email that resolves to nobody and confirm it writes nothing back. The lookup costs no credits on a miss, and the thing being tested is whether your worker knows the difference between an empty answer and an error.
- Read x-daily-requests-left after a hundred-record backfill. That number against your seat count is what tells you whether a full-database pass is one night or a week.

## 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 webhook action is not in the automation builder | Pipedrive states that if webhooks are not pre-built you cannot add the webhook action, and that existing webhooks cannot be re-used for automations. | Create a new webhook of the Automation webhook type in Settings, as a global admin. A regular webhook already in the account will not appear, however well it works elsewhere. |
| The webhook will not save and the URL looks fine | Pipedrive requires the endpoint URL to conclude with a slash, an ampersand, a question mark or an equals sign, to prevent malformed URLs being assembled from a base domain and a path. | Add the trailing character. It is the least guessable requirement on this page and it produces no useful error message. |
| The automation fires and nothing is ever enriched | The webhook action sends and does not receive. The documented inputs are a webhook, a method, a body and a path, with nothing handed to a later step. | Put a worker in the middle: the native Zapier app, an n8n workflow or your own service. The automation is the trigger, and the enrichment and the write-back both happen outside the CRM. |
| The whole automation execution failed | Pipedrive states that if the webhook is not working any more or is missing authentication or permissions, the automation execution will fail. Webhook executions also count against the normal automation execution limits and pause when those are reached. | Check the execution history, which shows the final body and path. A worker returning a 500 fails the automation rather than being retried quietly, which is better behaviour than it feels like at the time. |
| 429 on the write-back, with the daily budget nowhere near spent | That is a burst limit rather than the daily one. Burst limits are per token, per user, on a rolling 2-second window: 20 requests on Lite up to 120 on Ultimate for an API token, and 80 up to 480 for an OAuth app. | Pace the worker and read x-ratelimit-remaining and x-ratelimit-reset. A search is the one to watch: 10 requests every 2 seconds on every plan and every authentication type. |
| A 403 and an HTML page from Cloudflare | Pipedrive documents that continuing to send high volume after a 429 earns a 403, returned as a Cloudflare HTML error page rather than as an API response, and that only high-volume api_token traffic is blocked this way. | Stop retrying, fix the pacing, and parse the rate-limit headers instead of the clock. A worker that treats 429 as a reason to try harder turns a recoverable limit into a block. |
| The budget ran out earlier in the day than expected | The daily token budget is shared across every user and integration on the account, and the endpoints are weighted: a list read is 20 tokens and a search is 40 against 2 for a single read. | Read x-daily-requests-left, replace loops of single reads with filtered list calls, and check whether something else on the account is spending it. Admins are notified automatically as the budget nears its end. |
| The reset did not happen when the day did | Pipedrive documents that the token budget resets at midnight in the server timezone, which may not be aligned with the timezone you are in. | Schedule a backfill against the server reset rather than local midnight, and confirm the reset time by watching x-daily-requests-left rather than assuming it. |

## What breaks, from the vendors' own docs

- **The webhook action cannot use the response.** Pipedrive's documentation for the automation webhook covers the body, the path and the execution history, and describes no way to read the response into a later step. Treat it as fire and forget: the enriched fields come back through a separate API call, from whatever received the webhook.
- **Global admin only, and the webhook must exist first.** The action is available to global admin users, and it will only offer webhooks already created in Settings as Automation webhooks. Existing webhooks cannot be reused. If the action is missing from the builder, that is usually why.
- **Automations are a plan feature, under two names.** The support article says Advanced and higher; the pricing page sells Lite, Growth, Premium and Ultimate and lists automations from Growth. Both are Pipedrive's own pages and they use different plan names for the same gate, so check the account.
- **The API budget is tokens, not calls.** The daily allowance is 30,000 base tokens times the plan multiplier, 1 on Lite rising to 7 on Ultimate, times seats. Reading one record is 2 tokens, a list is 20, an update is 10 and a search is 40. Exhausting it returns 429 until midnight in the server timezone, which may not be your midnight.
- **Bursts are capped per token, every two seconds.** On top of the daily budget there is a rolling two-second window: 20 requests on Lite up to 120 on Ultimate for an API token, and 80 up to 480 for an OAuth app. Search is 10 per two seconds on every plan and every auth type, which is the one that catches a backfill.
- **A failing webhook fails the automation.** Pipedrive states that if the webhook stops working or is missing authentication or permissions, the automation execution fails. Webhook executions also count against the normal automation execution limits, and pause when those are reached.

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

- Pipedrive: automations webhook requests: https://support.pipedrive.com/en/article/automations-webhook-requests
- Pipedrive developer docs: rate limiting: https://pipedrive.readme.io/docs/core-api-concepts-rate-limiting
- Pipedrive pricing: https://www.pipedrive.com/en/pricing
- 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-11, summarised on the page: https://www.reversecontact.com/integrations-hub/reverse-contact-integrations/pipedrive-reverse-contact-integration#reddit
- This pair, with the reasoning behind each step: https://www.reversecontact.com/integrations-hub/reverse-contact-integrations/pipedrive-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.*
