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.

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.

WhatDirectionWhat 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 GoogleIn Reverse ContactWhat 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 missingWhat it costs in an enrichment run
Row lockingTwo 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 updatesA 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 identitySorting, 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 writeA 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 minutesThe 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 authorNot 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.

Field map

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.

Pick one on each side.

Where the call runsA 500ms cached lookupA 1,000-row passA live job that takes minutesRunning 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.
Setup checklist 0 of 8 done

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

01

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.

02

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.

03

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.

04

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.

05

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.

06

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.

07

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.

08

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

Checked by

Reverse Contact

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 · How we checked, and what we will not claim

Researched and written by

Eugene Suslov

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

The integration moves the record. Something has to fill it.

Reverse Contact resolves an email, a domain or a profile URL into a verified people and company record, through one API with a consistent schema. It sits under Google, Reverse Contact and everything else in this directory, and it returns null with a confidence score rather than a guess.

Free trial, no card required, and 500 credits to start.

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