---
title: "Google Workspace and Reverse Contact integration: what syncs, and what it needs"
description: "Google Workspace and Reverse Contact: what moves, in which direction, which plan carries it, and the limits that bite. Verified October 2026."
url: https://www.reversecontact.com/integrations-hub/google-integrations/google-reverse-contact-integration
format: markdown twin of the page above, generated at build time
---

New Unlimited plans are here. Fetch, search and enrich without counting credits. [See plans →](https://www.reversecontact.com/integrations-hub//pricing#plans)

Reverse Contact

### Products

Data

People Data

Company Data

Our Data Quality Standard

Delivery methods

API

Webhooks

CSV Enrichment

MCP

CLI

Integrations

### Use cases

[Sales Product](https://www.reversecontact.com/integrations-hub//use-case/sales-products)[Recruiting Product](https://www.reversecontact.com/integrations-hub//use-case/recruiting-products)[Internal Data Teams](https://www.reversecontact.com/integrations-hub//use-case/internal-data-teams)[AI Products](https://www.reversecontact.com/integrations-hub//use-case/data-for-ai)[CRM Enrichment](https://www.reversecontact.com/integrations-hub//use-case/crm-enrichment)

### Features

[Email Finder API](https://www.reversecontact.com/integrations-hub//feature/email-finder-api)[Phone Number Enrichment](https://www.reversecontact.com/integrations-hub//feature/phone-number-enrichment)[People Search API](https://www.reversecontact.com/integrations-hub//feature/people-search-api)[Agentic Search API](https://www.reversecontact.com/integrations-hub//feature/agentic-search-api)[People Lookalike API](https://www.reversecontact.com/integrations-hub//feature/people-lookalike-api)[Company Search API](https://www.reversecontact.com/integrations-hub//feature/company-search-api)[Person Enrichment API](https://www.reversecontact.com/integrations-hub//feature/person-enrichment-api)[Company Enrichment API](https://www.reversecontact.com/integrations-hub//feature/company-enrichment-api)[Person Social Data API](https://www.reversecontact.com/integrations-hub//feature/social-person-api)[Company Social Data API](https://www.reversecontact.com/integrations-hub//feature/social-company-api)

Security

Pricing

Docs

[Log in](https://app.reversecontact.com/auth/login) [Book a demo](https://www.reversecontact.com/contact?utm_source=integrations-directory&utm_medium=referral&utm_campaign=tool-integrations&utm_content=site-header) [Start for free](https://app.reversecontact.com/auth/signup?utm_source=integrations-directory&utm_medium=referral&utm_campaign=tool-integrations&utm_content=site-header)

# Google Workspace and Reverse Contact

Featured

A custom function gets 30 seconds. A script gets six minutes. A live job can take tens of them.

Checked by **Reverse Contact** · Verified 2026-10-28 · No paid placement

## 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, in.

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.

## What actually syncs

Object by object, with the direction each one moves in. This is the table to read before the feature list, because a capability that only moves one way is a different product from the one you think you are buying.

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

Nothing in that table moves in both directions. Whichever system you treat as the source of record, the other one is downstream of it, and a correction made in the wrong place does not travel.

## 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 few things are worth knowing before you plan around this mapping, because each one is a decision somebody has to own rather than a setting to find.

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

Every row above travels as a file: eight field mappings, six what is missing rows and four documented exclusions, each one's note, and the six vendor documents behind them. The CSV opens in a spreadsheet, the JSON is the shape an agent wants, and the Markdown is the table to paste into a ticket.

Every row in the second table is survivable and the third is the one that actually hurts, because it produces a wrong answer rather than a missing one. The reason the checklist above starts with an id column instead of an API key is that a credential can be replaced in a minute and an identity scheme cannot be added to a sheet that has already been sorted.

## Where the call can run, and what each place 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. Pick one on each side and the grid marks the answer.

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

## How to connect Google to Reverse Contact

Every step below is from the two vendors' own setup documentation, in the order they document it. Two of them cost you an afternoon if taken late, so the order is the useful part rather than the clicks.

- **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 it takes** — An hour for a working script. An afternoon for one that can be left alone.

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.

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.

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.

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.

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.

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.

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.

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.

Hand it to an agent instead

The same sequence, the sync table, the documented limits and the error list ship as one agent skill. Point Claude Code, Cursor or anything that reads a file at [this pair as a skill](https://www.reversecontact.com/integrations-hub/skills/google-reverse-contact.md) and it has the whole pair without reading two sets of vendor docs first.

curl -o .claude/skills/google-reverse-contact/SKILL.md https://www.reversecontact.com/integrations-hub/skills/google-reverse-contact.md

## What breaks, and what nobody tells you

Every limit below is documented by one of the two vendors. They are here because they change decisions, not because they are flaws.

- **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.

Each of those is documented behaviour rather than a fault, so none of them is going to be fixed by a support ticket. The ones that produce a symptom you would misread are below.

## The 8 failures people actually hit

Each one below is a symptom somebody reports, the documented reason behind it, and the fix. Most are configuration rather than faults, which is why they survive a support ticket.

### The enrichment landed on the wrong person

WhyThe 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

WhyApps 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

WhyThe 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

WhyA 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

WhyA 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

WhyUrlFetch 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

WhyWrites 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

WhyA 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.

If none of those is it, the next thing to check is the thing most pairs fail on: whether the plan you are on carries the feature at all, which the grid above answers. The [same symptom on another pair](https://www.reversecontact.com/integrations-hub/errors) is often the same cause, so the directory indexes all of them by the message rather than by the integration.

## When this is the right integration

### Set it up when

- A list somebody is reviewing by hand before it goes anywhere
- Measuring your own match rate on 500 rows before committing to anything
- A one-off backfill where the sheet is the deliverable

### Do not bother when

- Two jobs or two people write the same rows
- The answer has to be waited for rather than checked later
- Somebody other than the person who built it has to keep it running

The right-hand column is the one worth being honest about, because every item in it is a reason to spend the budget somewhere else in the stack rather than a reason to configure harder.

## What practitioners say about it

Searched for the problem this pair solves rather than for the pair itself, because the pair by name returns almost nothing. 14 threads from 2022 to 2026 were read in full on 28 October 2026, and the 5 below are the ones that carry a point. Each is one person's experience rather than a measurement, and the vendors' own documentation is what the rest of this page rests on.

### The thing that forces the move is locking, not volume

> The thing that usually forces the move off Sheets is concurrent writes with no atomic state updates: two runs touching the same rows, or a run dying halfway with nobody knowing which rows it claimed. The minimal upgrade that fixes it is moving queue state into a table with a status column plus a claimed-by/claimed-at field \[...\] and keeping the sheet as the human-readable dashboard on top.

[r/automation](https://www.reddit.com/r/automation/comments/1x1d243/using_google_sheets_as_the_queue_for_a/) · October 2026 · 1 points

The clearest statement of the argument this page makes, including the upgrade path. Note what it does not say: nothing about quotas, nothing about speed. The sheet fails as a queue rather than as a store, and the recommended ending is the one this page recommends too, which is that the sheet stays and stops being the thing that holds the state.

### A row number is not a name, and sorting proves it

> I would test sorting the sheet, inserting a row and changing a company's domain while a request is still running. A result should return to a stable job ID, not whichever company now occupies the old row number. \[...\] If someone corrects the domain during the run, the returned result belongs to the earlier input and should not silently overwrite the corrected record.

[r/automation](https://www.reddit.com/r/automation/comments/1x1d243/using_google_sheets_as_the_queue_for_a/) · October 2026 · 1 points

This is the test in the verify list above, and it was somebody else's idea first. The second half is sharper than anything in the documentation: if a person fixes a domain while the lookup for the old one is in flight, the answer that comes back is correct for an input that no longer exists. Keeping the submitted input alongside the job is the cheap defence, and almost nobody does it.

### Paid for and not written is a state your sheet cannot see

> filled-in fields only prevent a second charge after the first result was saved \[...\] if the api billed you & the sheet write failed, the row still looks pending \[...\] i'd store the request id before calling & keep that row unresolved until you check the provider. a new database won't fix that gap by itself

[r/automation](https://www.reddit.com/r/automation/comments/1x1d243/using_google_sheets_as_the_queue_for_a/) · October 2026 · 1 points

Written about enrichment APIs generally and it lands exactly on the one Reverse Contact endpoint that bills on a miss: a live fetch is charged 2 credits when the job is created and keeps them whatever comes back. Storing the task id before waiting, which is what this comment recommends, is the same instruction as step seven of the checklist, arrived at from the billing side rather than the engineering one.

### The real bill is maintenance, and it arrives at 2am

> The other thing nobody talks about is maintenance. When an API changes its response format at 2am and your enrichment run silently fails, that's now your problem. With clay or any managed tool, that's their problem. With a custom stack it's always your 7am fire drill. \[...\] ask yourself who's going to maintain this 6 months from now when you're heads down on something else.

[r/gtmengineering](https://www.reddit.com/r/gtmengineering/comments/1s9ylfe/supabase_google_sheets_claude_code_replaced_clay/) · April 2026 · 2 points

A fair reply to somebody who had just replaced a managed tool with a spreadsheet and some code, and the directory has a concrete example of the risk it names: Reverse Contact replaced /v2/resolve with /v2/enrich and documented the old path as live only until 13 October 2026. A hand-written script is where that change lands on you rather than on a vendor, which is the honest cost of the cheapest route here.

### The architecture was obvious four years before the tools were

> I was thinking more for getting the emails in the first place. You give it a domain and it gives you email addresses attached to it. You could just have zapier go through the spreadsheet for websites and then send that to an email/phone scraping API to get and confirm contact details to put in the sheet.

[r/zapier](https://www.reddit.com/r/zapier/comments/sufa4z/data_enrichment_in_google_sheets/) · February 2022 · 2 points

Four years before this page, somebody describing the orchestrator row of the grid above from first principles, in a thread where the rest of the discussion was about getting round anti-scraping measures. The shape has not changed and the inputs have: a domain into a company lookup is 2 credits and a published endpoint now, rather than something you had to go and scrape.

What the threads add up to

Nobody discusses this pair by name, so the search was for the job: enriching a list of leads that lives in a spreadsheet. One thread is about precisely this and reads like a post-mortem, which is the most useful material in any of the seven harvests. The agreement across four years is striking: nobody argues that a sheet cannot do it, and everybody who has done it warns about the same three things, none of which are rate limits.

Three of the five come from one thread, which is unusual here and happened because somebody wrote the post-mortem this page needed. Taken together the five say the quotas are not the problem, and that is also what Google's own documentation says: the generous numbers are the daily ones and the brutal ones are the clocks.

## The longer answer

This page is the honest answer to a question the rest of the directory avoids, which is what to do when there is no budget and no CRM. Apps Script is free with a Google account, UrlFetchApp will call anything, and the result lands in a cell, so the whole build is one script and an API key. The reason it is not the recommended route everywhere is not capability but durability, and the difference shows up in week three rather than on day one.

The thing a spreadsheet is genuinely best at is the measurement nobody does. Reverse Contact publishes a 70%+ identity match rate as a global figure and says to measure your own, and 500 rows in a sheet with a column for the answer is the cheapest way anybody has to do that. [The Clay route](https://www.reversecontact.com/integrations-hub/clay-integrations/clay-reverse-contact-integration) does the same job on Clay credits without a Reverse Contact account at all, which is better still if Clay is already there.

Where this build survives contact with a team, it is usually because the sheet stopped being the queue and became the screen. Move the job state to something that can lock a row and keep the sheet as the view, or hand the whole loop to [n8n](https://www.reversecontact.com/integrations-hub/n8n-integrations/n8n-reverse-contact-integration), which is the one orchestrator here that can poll an asynchronous job properly. Both of those are upgrades from a spreadsheet rather than replacements for it, and the sheet usually stays.

## If this is not the one

The integrations people compare this against, or set up alongside it.

Split a stack into layers and this pair sits on two of them: the [collaboration layer](https://www.reversecontact.com/integrations-hub/stack/collaboration), which 15 of the 68 integrations here touch, and the [data layer](https://www.reversecontact.com/integrations-hub/stack/data), which 26 do.

[**HubSpot and Reverse Contact**A whole record from an email or a domain, by four routes, and only the in-CRM one needs Data Hub. One way, in](https://www.reversecontact.com/integrations-hub/hubspot-integrations/hubspot-reverse-contact-integration)[**HubSpot and Google**Four integrations under one name, all free to connect, each gated somewhere else. Two-way sync](https://www.reversecontact.com/integrations-hub/hubspot-integrations/hubspot-google-integration)[**Salesforce and Reverse Contact**No AppExchange listing, and the callout limits are the real design constraint. One way, in](https://www.reversecontact.com/integrations-hub/salesforce-integrations/salesforce-reverse-contact-integration)

## [Reverse Contact](https://www.reversecontact.com)

We sell B2B people and company data, and we publish this directory. Every tier requirement, sync direction and limit on this page was read from a vendor's own knowledge base, developer documentation or pricing page on the date below. Nothing on it is restated from a press release or a third-party listing.

Where a vendor publishes no public figure, this page says so rather than estimating, which is why no page here prints a cost per enriched record. Reverse Contact appears in this directory as a data provider and publishes it. No other vendor pays for placement, and every link out of a listing or a citation carries nofollow, including the ones that point at Reverse Contact. The only followed links on this page are the two calls to action and the reviewer.

One fact about the publisher, stated here rather than in the page above it: Reverse Contact has no CRM marketplace app and no app inside a sequencer. Its three native apps are on Clay, Zapier and Make, and every other route is its API, its CLI or its MCP server. That is a deliberate shape for a data layer rather than a missing release, and it is what the routes on this page are describing.

Tier requirements, sync behaviour and documented limits change without notice. Confirm against your own contract before you budget. [What has changed since](https://www.reversecontact.com/integrations-hub/changes) · [How we checked](https://www.reversecontact.com/integrations-hub/methodology), and what we will not claim

[Eugene Suslov](https://www.linkedin.com/in/eysuslov/)

Researched and wrote every page in this directory, and checked every tier requirement, sync direction and documented limit against the vendor's own knowledge base, developer documentation or pricing page.

- **Verified** — 2026-10-28
- **Sources** — 6 vendor documents
- **Paid placement** — None

### Read from

- [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)

## Google and Reverse Contact, asked and answered

### Is there a Google Workspace Reverse Contact integration to install?

No. Reverse Contact publishes nothing on the Google Workspace Marketplace, and its own apps are on Clay, Zapier and Make. What you build instead is Apps Script calling the API with UrlFetchApp, which needs no account beyond a Google one and is the only surface in this directory that can send a request, read the answer and do it without a plan upgrade.

### Can I write =ENRICH(A2) as a custom function in a cell?

You can, and it is the worst of the four options. A custom function gets 30 seconds per execution, which is plenty for a lookup documented at 500ms, but the sheet recalculates whenever it feels like it and every recalculation is another billed call. Use a script or a trigger that writes a value once, and leave the cell holding a value rather than a formula.

### How many calls a day does Apps Script allow?

UrlFetch is 20,000 calls a day on a consumer gmail.com account and 100,000 a day on a Google Workspace account, per user, resetting 24 hours after the first request. The Workspace figure is the same number as Reverse Contact's own daily ceiling on the Unlimited plans, so above about 100,000 records a day both sides stop at once.

### Can a spreadsheet wait for a live enrichment job?

Not in one execution. Apps Script gives a script 6 minutes and a custom function 30 seconds, while a live job aims for under 15 seconds and is documented as possibly taking tens of minutes. The workable pattern is a time-driven trigger that stores the task id, exits, and checks again on its next run, because polling is free and off the rate-limit clock.

### Is a spreadsheet a reasonable place to run this at all?

For a list somebody is reviewing by hand, yes, and it is the cheapest honest answer in the directory. For a queue that two jobs write to, no: a sheet has no row locking and no atomic status, so a run that dies halfway leaves rows nobody has claimed. The usual answer is to keep the sheet as the screen people read and move the job state somewhere that can lock a row.

Tier requirements, sync behaviour and limits read from each vendor's own documentation in September, October and November 2026. Vendors change these without notice.

Reverse Contact appears in this directory as a data provider and publishes it. Every other tool is here on merit and nobody pays for placement.

Ask an assistant
