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

# Google Workspace and Reverse Contact

> Generated from https://www.reversecontact.com/integrations-hub/google-integrations/google-reverse-contact-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:** A Google account, a Reverse Contact API key, and Apps Script or an orchestrator that can read the sheet

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

## The short version

A spreadsheet is the only tool in this directory that can call an API, read the answer and do it without paying anybody more, which is why so many enrichment pipelines live in one and why so many of them quietly break. The limits that matter are not rate limits but clocks: 30 seconds inside a cell, 6 minutes inside a script, and a live job that may take longer than both. Build it as a trigger that checkpoints, keep the sheet as the thing people look at, and do not let a formula be the thing that spends credits.

## Where the call can run, and what each place can finish

Rows: Where the call runs. Columns: What it can finish. Nothing here is gated by a Google plan, which makes this the one page in the directory where the question is not what you pay but where the code sits. The four surfaces have different clocks and the clocks are what decide the build, so the column to read first is the third one. Every figure is from Google's own quota documentation.

| Where the call runs | A 500ms cached lookup | A 1,000-row pass | A live job that takes minutes | Running with nobody watching |
|---|---|---|---|---|
| A custom function in a cell | Yes | No | No | No |
| A script run by hand | Yes | Partly | No | No |
| A time-driven trigger | Yes | Yes | Partly | Yes |
| An orchestrator reading the sheet | Yes | Yes | Partly | Yes |
| Your own code on the Sheets API | Yes | Yes | Yes | Yes |

- **Yes.** Documented and unambiguous. Every surface clears a lookup published at 500ms at the 95th percentile. A time-driven trigger gets 90 minutes of total runtime a day on a consumer account and six hours on Workspace, which is enough passes for a thousand rows, and your own code against the Sheets API has no runtime cap at all.
- **Partly.** True with a condition. A hand-run script has 6 minutes, so a thousand rows fit only if each one is quick and the writes happen as you go. A trigger and an orchestrator can reach a live job by storing the task id and checking on a later run, which works because polling is free and off the rate-limit clock, but neither waits.
- **No.** Not true on that one. A custom function gets 30 seconds and, worse, re-runs whenever the sheet recalculates, so every recalculation is another billed call. Nothing with a 30-second or 6-minute ceiling reaches a live job documented as possibly taking tens of minutes, and neither a formula nor a script somebody clicks runs unattended.

Counted off that grid, of twenty pairings: twelve give you yes, three give you partly, five give you no.

The first row is the one everybody wants and the only one with three answers of No, which is the finding: the obvious thing, a function you type into a cell, is the worst version of this build and it bills you every time the sheet recalculates. The last row is best and is not inside Google at all, so the honest reading is that a spreadsheet is an excellent place to hold the list and a poor place to run the loop.

## What actually syncs

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

| What | Direction | What that means in practice |
|---|---|---|
| The queue | One way, out | Rows with an email or a domain and an empty answer column, read by Apps Script or by an orchestrator. |
| The lookup | One way, out | UrlFetchApp to POST /v2/enrich/persons. 2 credits on a match, nothing on an error. |
| The answer | One way, in | Written back to the row, keyed on a stable id rather than on a row number. |
| The state | One way, in | A status column and a timestamp, so a run that dies halfway can be resumed rather than repeated. |

## Which field lands where

A sheet imposes no schema, which is why this map is worth writing down: the columns are whatever you decide, so the decision is yours and it is easy to make badly. What follows is the shape that survives somebody sorting the sheet.

| In Google | In Reverse Contact | What to know about the match |
|---|---|---|
| A stable id, written once | Column A, never reused | The thing every write is keyed on. A row number is a position rather than an identity and changes the moment anybody sorts or filters. |
| An email in the row | POST /v2/enrich/persons, 2 credits | Identity, the current role and the company on one schema. A miss returns null with a confidence score and costs nothing. |
| A domain in the row | POST /v2/enrich/companies, 2 credits | Firmographics from a domain. Deduplicate the domains first, because a list of people at twenty companies needs twenty company calls rather than a hundred. |
| A profile URL in the row | POST /v2/fetch/persons, 1 credit | Half the price, and unmetered from the $249 plan rather than the $699 one. A list exported from a profile source usually already has this column. |
| currentPosition.title and companyName | Two columns the script owns | Keep them separate from anything a person types in, because a script that overwrites a hand-corrected cell is the fastest way to lose the team's trust in the sheet. |
| The confidence score | A number column, not a hidden rule | In a sheet the threshold can be a formula somebody can see and argue with, which is better than a constant buried in the script. |
| A live job's task id | Its own column, written before the wait | The 2 credits are charged at job creation and kept whatever comes back, so the id is the only record that you have already paid. |
| The status and the timestamp | Two columns, both required | What makes the run resumable and what stops a second pass paying again for a miss. Without them an empty answer cell means two different things. |

### What a spreadsheet cannot promise you

The limits worth planning around here are not the published quotas, which are generous, but the guarantees a sheet does not make. Each row below is a property that a database has and a spreadsheet does not, with what it costs you in this particular build.

| What is missing | What it costs in an enrichment run |
|---|---|
| Row locking | Two runs write the same row, one value survives, and no error is raised anywhere. The run reports success and the sheet is wrong |
| Atomic status updates | A row can be charged for and not written, because the call and the write are two operations. The row then looks untried and the next pass pays again |
| Stable row identity | Sorting, filtering or inserting moves every row below it, so an answer addressed to a position lands on a different person. Plausible, silent and wrong |
| A transaction around the call and the write | A six-minute timeout loses every answer held in memory. Write as you go and spend Sheets calls instead, because those are the cheap ones |
| Any wait longer than six minutes | The live endpoints are out of reach in a single execution, whatever the plan. Store the task id and poll on the next trigger run, which is free |
| Somebody other than the author | Not a technical limit and the one that actually ends these builds. A script nobody else can read is a dependency on one person being available |

**What does not cross:**

- A Google Workspace Marketplace app. Reverse Contact publishes none, which is consistent with apps on Clay, Zapier and Make and nothing inside any CRM, sequencer or productivity suite.
- A supported way to wait for a live job in one execution. The runtime caps are 30 seconds in a custom function and 6 minutes in a script, on every account type.
- A business email or a direct phone number in a formula. Both are separate endpoints at 3 and 20 credits, charged only when one is found, and both are asynchronous.
- Anything that makes a sheet transactional. The status column is a convention you maintain, not a guarantee the store provides.

## Connect it, in this order

**Who has to do it:** Anybody with a Google account and the Reverse Contact key. No administrator is involved, which is the appeal and the risk.
**How long:** An hour for a working script. An afternoon for one that can be left alone.

### 1. Give every row a stable id before anything else, because this cannot be retrofitted

*Where:* Column A of the sheet

An answer has to come back to an identity rather than to a position, and the moment somebody sorts or filters the sheet a row number stops meaning anything. Write an id once, never reuse one, and key every write on it. This is the only step on the page that is painful to add later.

### 2. Decide which column is the status, and what its values are

*Where:* The sheet, as a real column

Three values are enough: not tried, resolved, and tried and unresolved. An empty answer cell cannot distinguish between a row nobody has reached and a row where the lookup honestly found nothing, and that distinction is what stops you paying twice for the same miss.

### 3. Put the API key in Script Properties, not in a cell

*Where:* Apps Script: Project Settings > Script Properties

A key in a cell travels with every copy of the sheet, every export and every share, and there is no way to take it back out of somebody's downloaded copy. Script Properties stay with the script, and the key goes on the Authorization header rather than in the URL.

### 4. Check before you fetch, on the endpoint that costs nothing

*Where:* POST /v2/fetch/persons/check

The free check says whether a profile is cached and when it was last updated, so a sweep spends 2 credits only where the answer is missing. Errors cost nothing either, so a thin list is cheap to discover on the Reverse Contact side even though it still spends your UrlFetch quota.

### 5. Write the answer before moving on to the next row

*Where:* Your script loop

Resist batching the writes to the end of the run, because a six-minute timeout then loses every answer you have paid for. Write each row as it resolves and accept the extra Sheets calls, which are limited at 60 a minute per user and are the cheaper thing to spend.

### 6. Make the script resumable, then put it on a trigger

*Where:* Apps Script: Triggers

A script gets 6 minutes per execution whatever you pay, so a list of any size has to be processed in passes that start where the last one stopped. Reading the status column is what makes that work, and it is why the status column is step two rather than an afterthought.

### 7. Decide what happens to a live job before you call one

*Where:* Your own design

A live fetch returns a task id rather than a record, charges its 2 credits when the job is created and keeps them whatever comes back. Store the task id on the row immediately, and let the next trigger run check it, because nothing in Apps Script can wait that long.

### 8. Run 500 rows and count, which is the whole point of doing this here

*Where:* The sheet itself

The published 70%+ identity match rate is a global average and Reverse Contact says to measure your own. Five hundred of your own rows and a formula give you the number that decides whether any of the rest of this directory is worth building, and a spreadsheet is the cheapest place there is to get it.

Only the first two steps are expensive to add late, and both are about identity rather than about the API: what a row is called, and what state it is in. Everything else can be rewritten in an afternoon, which is the real argument for prototyping here before building anywhere else.

## How to check it worked

- Sort the sheet while a run is in progress, deliberately. If an answer lands on the wrong person, the write is keyed on a row number and that is the bug to fix before anything else happens.
- Kill the script mid-run and start it again. It should skip what resolved and retry only what did not, and if it starts from the top you are paying for the same rows twice.
- Put a formula version of the lookup in one cell and then edit an unrelated cell. If the lookup runs again, you have found out why a custom function is the wrong shape, at a cost of 2 credits.
- Run the free check on somebody you know is current and read the update date. If it is recent, a live refresh buys nothing and you have avoided the one endpoint here that bills on a miss.

## 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 enrichment landed on the wrong person | The write was keyed on a row number and somebody sorted, filtered or inserted a row while the run was going. | Key every write on an id in column A that is written once and never reused. This is the one failure here that produces a confident wrong answer rather than a missing one, which makes it the worst. |
| Exceeded maximum execution time | Apps Script allows 6 minutes per script execution and 30 seconds per custom function, on every account type. | Process in passes driven by the status column and put the script on a time-driven trigger. There is no plan that raises the per-execution ceiling, so a resumable loop is the only shape that works. |
| Credits were spent and the rows still look untried | The call and the write are two operations, so a run that is charged and then fails to write leaves the row in its original state. | Write a status and a timestamp as soon as the call returns, and store a live job's task id before waiting on it. A live fetch keeps its 2 credits whatever comes back, which is the one endpoint where this gap costs real money. |
| Two people ran it and one set of answers vanished | A spreadsheet has no row locking, so concurrent writes resolve to whichever one landed last with no error raised. | Make one writer responsible, or move the job state to a store that can claim a row and keep the sheet as the review screen. Nothing in Apps Script makes a sheet transactional. |
| A formula in a cell is spending credits on its own | A custom function re-runs whenever the sheet recalculates, and each run is another billed API call. | Use a script or a trigger that writes a value, so the cell ends up holding an answer rather than an instruction to go and buy one again. |
| Service invoked too many times for one day: urlfetch | UrlFetch is capped at 20,000 calls a day on a consumer gmail.com account and 100,000 on Workspace, per user, resetting 24 hours after the first request. | Deduplicate domains before enriching companies and run the free check first, which is the cheapest way to cut the call count. Note that the Workspace figure matches Reverse Contact's own 100,000 profile daily ceiling, so at that scale both sides stop together. |
| A 429 from the Sheets API during a write-heavy run | Writes are limited to 60 a minute per user per project and 300 a minute per project, counted separately from reads. | Back off with truncated exponential backoff as the documentation says rather than retrying straight away. There is no daily limit, so slowing down costs nothing but time. |
| The whole thing broke and the only person who understood it has left | A script in one person's account with the logic in their head, which is the normal end state of a spreadsheet pipeline. | Keep the credential in Script Properties, the status model in the sheet where it is visible, and a comment at the top saying what the columns mean. None of that is technical work and it is the difference between a prototype and something a team owns. |

## What breaks, from the vendors' own docs

- **A custom function gets 30 seconds, a script gets six minutes.** Both figures are the same on a consumer account and on Workspace, so there is no upgrade that buys more time. A lookup documented at 500ms at the 95th percentile fits either; a live job documented as possibly taking tens of minutes fits neither, and that is the one constraint on this page that no amount of care works around.
- **UrlFetch is 20,000 a day, or 100,000 on Workspace.** Per user, resetting 24 hours after the first request rather than at midnight. A response is capped at 50 MB with 100 headers and 8 KB of header data per call, none of which an enrichment response comes near.
- **Triggers get 90 minutes a day, or six hours on Workspace.** That is total runtime across all time-driven triggers on the account, which is the real budget for an unattended sweep. On a consumer account 90 minutes a day is fifteen six-minute executions, so the checkpoint has to be efficient rather than merely present.
- **The Sheets API is 60 writes a minute per user.** 300 requests a minute per project and 60 a minute per user per project, counted separately for reads and writes, with no daily limit at all. Exceeding it returns 429 and the documented remedy is truncated exponential backoff, so a writer that retries immediately makes it worse.
- **A sheet has no row locking.** Two runs writing the same row produce one surviving value and no error, and a run that dies halfway leaves rows that look pending and are not. Nothing in Apps Script or the Sheets API fixes this; it is a property of the store, and the fix is a status column with an owner and a timestamp.
- **A row number is not an identity.** Sorting a sheet, inserting a row or filtering it moves every row below the change. An answer that comes back addressed to row 412 lands on whoever is in row 412 now, which is a silent, plausible, wrong result of exactly the kind this directory refuses to publish.
- **A live fetch is billed even when it finds nothing.** Its 2 credits are charged when the job is created and kept whatever comes back, which is the one Reverse Contact endpoint where a miss costs money. In a sheet that matters more than elsewhere, because a failed write leaves the row looking unprocessed and the next run pays again.

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

- Google Apps Script: quotas for Google Services: https://developers.google.com/apps-script/guides/services/quotas
- Google Sheets API: usage limits: https://developers.google.com/workspace/sheets/api/limits
- 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-28, summarised on the page: https://www.reversecontact.com/integrations-hub/google-integrations/google-reverse-contact-integration#reddit
- This pair, with the reasoning behind each step: https://www.reversecontact.com/integrations-hub/google-integrations/google-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.*
