---
name: zoho-reverse-contact-integration
description: Connect Zoho CRM 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 Zoho and Reverse Contact together, or asks why data is not moving between them.
---

# Zoho CRM and Reverse Contact

> Generated from https://www.reversecontact.com/integrations-hub/reverse-contact-integrations/zoho-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, and Zoho CRM Enterprise or above for the in-CRM route

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

## The short version

Zoho is the only CRM here that ships a programming language, and with Enterprise it genuinely removes the middle layer: a workflow rule fires a Deluge function, invokeUrl calls Reverse Contact, and the same function writes the fields back. Thirty seconds of execution inside automation is more headroom than HubSpot gives custom code and more than Attio gives an HTTP block. Below Enterprise the honest answer is the same as everywhere else: a workflow webhook out to Zapier, Make or a worker, and the API to write back.

## Which function category has time for which job

Rows: The function category. Columns: What you are asking it to finish. The gate on this pair is the edition, and the thing that decides the design once you are past it is where the function is triggered from. Zoho gives a Deluge function a different execution ceiling per category, and the range is wide enough to change what is possible rather than just what is comfortable.

| The function category | One cached lookup and one write | Check freshness first, refresh only if stale | A live refresh, polled to completion | Fifty records in one run |
|---|---|---|---|---|
| Button, related list, validation rule or REST API: 10 seconds | Fits comfortably | Fits comfortably | Terminated | Terminated |
| Workflow, blueprint or approval: 30 seconds | Fits comfortably | Fits comfortably | Tight | Tight |
| Schedule: 15 minutes | Fits comfortably | Fits comfortably | Fits comfortably | Fits comfortably |

- **Fits comfortably.** Inside that category's documented timeout with room to spare. Reverse Contact publishes a 500ms P95 on the cached endpoints, so a lookup and a write is nowhere near any of these ceilings, and the free freshness check adds one more call and no credits.
- **Tight.** Possible, and close enough to the edge to be a gamble. A live job is documented as usually seconds and possibly tens of minutes, and Zoho terminates an over-running function rather than warning about it.
- **Terminated.** Forcefully terminated. Zoho says so in those words, and recommends designing long-running logic for the Schedule category while keeping the interactive categories lightweight.

Counted off that grid, of twelve pairings: eight give you fits comfortably, two give you tight, two give you terminated.

The bottom row is the finding, and it makes Zoho the only CRM in this directory that can poll a live job inside itself. Fifteen minutes is enough to start a refresh, wait for it and read the result, which neither a HubSpot custom code action at twenty seconds nor an Attio HTTP block at twenty can manage. The price is that a schedule is not a trigger, so fresh data arrives on your timetable rather than the prospect's.

## What actually syncs

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

| What | Direction | What that means in practice |
|---|---|---|
| Trigger | One way, in | A workflow rule on lead or contact creation, calling a Deluge function. |
| The call | One way, out | invokeUrl POSTs to /v2/enrich/persons with the Authorization header and the record's email. 2 credits. |
| The response | One way, in | Deluge parses the JSON in the same function and maps the fields you want. |
| Write-back | One way, in | zoho.crm.updateRecord sets the fields. That integration task spends an API credit as well as the function credit. |

## Which field lands where

On Enterprise and above the whole pair is one Deluge function: invokeUrl makes the call, the response arrives as a map, and zoho.crm.updateRecord writes the fields back. Below Enterprise the same list describes a worker somewhere else, reached by a workflow webhook.

| In Zoho | In Reverse Contact | What to know about the match |
|---|---|---|
| A workflow rule on Leads or Contacts | Nothing yet | The trigger. A workflow, blueprint or approval function gets 30 seconds of execution, which is more headroom than a HubSpot custom code action and the same as an Attio HTTP block. |
| invokeUrl, inside the function | POST /v2/enrich/persons, 2 credits | Identity, the current role, history, education, skills and location on one schema. The call itself costs nothing from either Zoho meter, because an outbound call is not a CRM API call. |
| invokeUrl, from a domain | POST /v2/enrich/companies, 2 credits | Firmographics from a domain or a company name. Run it on the account rather than once per contact attached to it. |
| The response, as a Deluge map | success, data, error, metadata, quotas | Five keys on every endpoint. metadata.updatedAt is the one worth reading before paying for a refresh, and quotas.workspace.credits.left is how the function can see its own balance. |
| zoho.crm.updateRecord | Your own prefixed fields | Costs an API credit at the Update Records rate, because Zoho includes Deluge integration tasks in API credit consumption. Insert, update and upsert take up to 100 records per call, and the maximum credit deduction for those is 10. |
| A scheduled function | A bulk pass, with 15 minutes | Where a backfill belongs, and the only category in Zoho with enough runtime to poll a live job to completion. Zoho recommends designing long-running logic here explicitly. |
| A workflow webhook, below Enterprise | Zapier, Make or your own worker | The fallback when functions are not available. The shape is then identical to the Pipedrive build: out to a worker, enrich, and back in through the API. |
| Anything outbound to Reverse Contact | Nothing at all | This is a read layer. No Zoho record or field is sent anywhere, and there is nothing in the product to send it to. |

### Two meters, and the quiet one is the one that runs out

A Deluge function draws on two separate pools at once, and Zoho started counting the second one deliberately, having previously had no way to identify calls made through integration tasks. An enrichment loop spends both, and the one that stops you is rarely the one you were watching.

| What you run | What it draws down |
|---|---|
| One function execution, written in Deluge | One function credit. Enterprise and Zoho One allow 20,000 free plus 500 per user licence plus add-ons, to a maximum of 400,000 |
| The same function written in Java, Node.js or Python | 1 function credit per 10 seconds of execution, so the meter becomes a clock |
| invokeUrl, calling Reverse Contact | Nothing from either Zoho pool, and the org-wide Invoke URL quota is 5,000,000 requests a day |
| zoho.crm.updateRecord inside that function | An API credit at the Update Records rate, because integration tasks count as API credit consumption |
| zoho.crm.searchRecords inside that function | An API credit at the search rate, and it falls under the sub-concurrency limit of 10 on every edition |
| The API credit pool itself | 50,000 plus 250 to 2,000 per licence in a rolling 24 hours. Capped at 100,000 on Standard and 5,000,000 on Enterprise |
| Running many at once | Concurrency is 20 per org per app on Enterprise. There is no per-minute limit at all: Zoho states you may make any number of calls a minute provided concurrency holds |

**What does not cross:**

- A marketplace app inside Zoho. Reverse Contact maintains apps on Clay, Zapier and Make and nothing inside any CRM, so the in-CRM route is one you write rather than one you install.
- Functions on Standard or Professional, other than through Extensions. Zoho states that full access begins at Enterprise, CRM Plus, Ultimate and Zoho One.
- A business email or a direct phone number. Both are separate endpoints at 3 and 20 credits, charged only when one is found, and the email finder is asynchronous as well.
- Anything travelling back to Reverse Contact. The direction runs one way and there is nothing in the product to write to.

## Connect it, in this order

**Who has to do it:** Somebody with the Manage Extensibility permission on an Enterprise edition or above, plus whoever can create a Reverse Contact API key. Below Enterprise, whoever runs the worker instead.
**How long:** Half a day for the Deluge route. Confirming the edition and the permission takes five minutes and saves most of it.

### 1. Check the edition and the permission together, because they fail identically

*Where:* Zoho: Setup, then profile Developer Permissions

Functions have full access on Enterprise, CRM Plus, Ultimate and Zoho One, and Standard and Professional can reach them only through Extensions. Separately, creating one needs the Manage Extensibility permission. An admin without that permission sees exactly what somebody on the wrong edition sees, which is nothing.

### 2. Decide trigger or schedule, because the ceiling differs by a factor of thirty

*Where:* Zoho: the function category

A workflow, blueprint or approval function gets 30 seconds. A scheduled one gets 15 minutes. A button, related list, validation rule or REST API function gets 10. Zoho terminates anything that exceeds its category, so this choice is the design rather than a setting.

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

*Where:* Zoho: Setup, Modules and Fields

Prefixed, and separate from anything a rep types into. The function writes with zoho.crm.updateRecord and will write exactly what you tell it, including an absent value, so the separation is what makes the pair safe to leave running.

### 4. Write the invokeUrl call and read the response map

*Where:* Zoho: the Deluge function

invokeUrl takes the URL, the type and the parameters, with the Authorization header carrying your key. Worth knowing before you paste it: the key lives in the function source, so anybody with Manage Extensibility can read it, which is a weaker position than a Salesforce Named Credential and stronger than a key in a third-party cloud.

### 5. Test for the key before you write the field

*Where:* Zoho: the Deluge function, again

Reverse Contact returns null rather than a best guess when it is not confident, so the response map simply has no key for an unresolved field. Three lines of Deluge checking for it is the difference between an enrichment that fills gaps and one that creates them.

### 6. Count both meters before you loop over anything

*Where:* Zoho: Setup, API Dashboard

Every function execution is one function credit, and the Deluge integration tasks inside it that touch CRM records cost API credits as well. Zoho says so explicitly, having previously had no way to identify those calls, so an enrichment loop draws down two pools at once.

### 7. Avoid searching from inside the function

*Where:* Zoho: the Deluge function

Search records invoked from a function is one of seven calls under the sub-concurrency limit, which is 10 across every edition. Fetching by id instead keeps you on the ordinary concurrency limit, which is 20 per org per app on Enterprise.

### 8. Put the bulk pass on a schedule and chunk it

*Where:* Zoho: Setup, Functions, Schedule

Fifteen minutes is generous and the 200,000 lines of execution cap is not a line count of your source: Zoho notes that loops, conditional branches and called child functions all contribute. Chunking a backfill is what keeps a scheduled pass inside both ceilings.

Steps one and two decide whether this build exists and what shape it takes, and both are answerable in ten minutes. That is the pattern across this whole set of pages: the enrichment is never the hard part, and the CRM's own rules about where code may run are. [Attio reaches the same place](pair:attio+reverse-contact) with three blocks and no language at all.

## How to check it worked

- Run the function on a record whose answer you know, then on an email that resolves to nobody. The second is the test: the field should be left alone rather than blanked, which is what the key check in step five is for.
- Point invokeUrl at the free check endpoint and read the update date. It costs nothing, it proves the header survives, and the date is what tells you whether a live refresh would buy anything.
- Run a loop over fifty records from a workflow function on purpose and watch it be terminated at 30 seconds. Seeing the category timeout fire once is cheaper than discovering it during a list import.
- Open the API Dashboard and read Credits by Application and Functions after that run. It attributes consumption to the function that caused it, which is the only way to see the second meter at all.

## 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 |
|---|---|---|
| There is no option to create a function anywhere | Two causes that look identical. Functions have full access on Enterprise, CRM Plus, Ultimate and Zoho One, with Standard and Professional reaching them only through Extensions. Separately, creating and managing them needs the Manage Extensibility permission under Developer Permissions. | Check the permission before the edition, because it is the cheaper of the two to fix and an admin without it sees exactly what somebody on the wrong edition sees. |
| The function was terminated partway through | Zoho enforces a timeout by category: 10 seconds for a button, related list, validation rule or REST API call, 30 seconds for workflow, blueprint and approval, and 15 minutes on a schedule. | Move the work to the Schedule category, which Zoho recommends for long-running logic. There is no setting to raise a category timeout, so this is a move rather than a tweak. |
| The function hit the lines of execution limit | A single invocation is capped at 200,000 lines of execution, and Zoho notes this counts lines the runtime actually executes: loops, conditional branches and called child functions all contribute. | Chunk the loop rather than widening it. A scheduled pass over records in batches counts far fewer lines than one that re-reads a collection on every iteration. |
| The API credit pool emptied and nothing called the API | Deluge integration tasks count as API credit consumption. Zoho changed this deliberately, having had no way to identify calls made through them, so zoho.crm.searchRecords costs the same as the Search Records API. | Open Credits by Application and Functions on the API Dashboard, which attributes consumption to the function that caused it. The X-API-CREDITS-REMAINING header appears on responses once you pass half the daily limit. |
| TOO_MANY_REQUESTS from a function making very few calls | That is the sub-concurrency limit, which is 10 across every edition and applies to seven expensive calls including search records invoked from a function, the Query API and the Composite API. | Fetch by id rather than searching from inside the function. Zoho notes that sub-concurrency does not apply to integration tasks at all, so the same work routed that way is subject only to the ordinary concurrency limit. |
| The function wrote an empty value over a real one | Reverse Contact returns null rather than a best guess when it is not confident, so the response map has no key at all for an unresolved field and Deluge writes the absence. | Test for the key before writing it, and keep the enrichment in prefixed fields of its own. Three lines of Deluge separate an enrichment that fills gaps from one that creates them. |
| A live refresh timed out inside the workflow function | The live endpoints answer with a webhookId rather than a record, and the workflow category allows 30 seconds against a job documented as usually seconds and possibly tens of minutes. | Move the live path to a scheduled function, where the ceiling is 15 minutes and the poll fits. Polling is free and off the rate-limit clock, so the only costs are the function credit and the waiting. |
| An endpoint that worked last week returns nothing | /v2/resolve was replaced by /v2/enrich and /v2/search/persons by /v2/search/people, with the old pair documented as live only until 13 October 2026. | Search your functions for both old paths and change every invokeUrl that carries one. The strings are in Deluge source, so one text search finds all of them, which is a genuine advantage of keeping this inside the CRM. |

## What breaks, from the vendors' own docs

- **Functions in full are Enterprise and above.** Zoho states that Functions are available on Enterprise, CRM Plus, Ultimate and Zoho One with full access, and that Standard and Professional can only access them through Extensions. The in-CRM route on this page therefore starts at Enterprise, and the fallback below it is a workflow webhook to something else.
- **Thirty seconds inside automation, ten elsewhere.** Category timeouts are 30 seconds for workflow, blueprint and approval, 10 seconds for a button, related list, validation rule or REST API call, and 15 minutes on a schedule. A function that exceeds its category is terminated. Put a bulk pass on a schedule rather than hoping a button will carry it.
- **Two meters, and the second one is quiet.** A function execution is one function credit; the Deluge integration tasks inside it that read or write CRM records are counted as API credits as well. Zoho says so explicitly, having previously not counted them. An enrichment loop therefore draws down both pools, and the API pool is the smaller one on Standard at 100,000 a day maximum.
- **API limits are credits and concurrency, not calls a minute.** The allowance is 50,000 credits plus 250 to 2,000 per user licence in a rolling 24 hours, capped at 100,000 on Standard and 3,000,000 on Professional, with 5,000 on the free edition. There is no per-minute limit; instead concurrency caps simultaneous calls per org per app at 5 on free rising to 20 on Enterprise.
- **You need the Manage Extensibility permission.** Creating and managing functions requires that permission under Developer Permissions in profile settings. An admin without it sees no option to create one, which reads like an edition problem and is not.

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

- Zoho CRM: functions platform limits and quotas: https://www.zoho.com/crm/developer/docs/functions/limits-quotas.html
- Zoho CRM: API limits: https://www.zoho.com/crm/developer/docs/api/v8/api-limits.html
- Zoho CRM pricing and editions: https://www.zoho.com/crm/zohocrm-pricing.html
- 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/zoho-reverse-contact-integration#reddit
- This pair, with the reasoning behind each step: https://www.reversecontact.com/integrations-hub/reverse-contact-integrations/zoho-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.*
