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

# ClickUp and Reverse Contact

> Generated from https://www.reversecontact.com/integrations-hub/clickup-integrations/clickup-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:** ClickUp Business or above for task webhooks, a ClickUp API token, and a Reverse Contact API key

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

## The short version

ClickUp can start this and cannot finish it. A Call webhook automation sends a task out at exactly the right moment, which is the hard half of most builds, and then there is no documented way to read the reply back into a custom field, so the answer returns through the API as a separate write. Two plan gates decide whether it is worth doing, and they do not line up: Business turns the webhook on and leaves you on the slowest rate limit ClickUp publishes.

## Two ClickUp staircases, and they do not line up

Rows: ClickUp plan. Columns: What the build needs. This pair is gated twice and the gates are on different floors. One is the Automations allowance that decides whether ClickUp can call out at all, the other is the API rate limit that decides how fast the answer can come back, and the plan that fixes the first leaves the second exactly where it was. Every figure is from ClickUp's own documentation.

| ClickUp plan | The Call webhook action exists | Actions enough for a 1,000-row pass | API fast enough for a backfill | Conditions to gate the trigger |
|---|---|---|---|---|
| Free Forever | No | No | No | No |
| Unlimited and Core | No | Just | No | No |
| Business | Yes | Yes | No | Yes |
| Business Plus | Yes | Yes | Yes | Yes |
| Enterprise | Yes | Yes | Yes | Yes |

- **Yes.** Documented and unambiguous. Task webhooks are listed as available from Business. Actions are 10,000 a month on Business and 100,000 on a new Business Plus plan. The API reaches 1,000 requests a minute on Business Plus and 10,000 on Enterprise, and conditions are a Business feature.
- **Just.** True with nothing to spare. Unlimited and Core get 1,000 Actions a month, which is exactly a thousand-row pass and leaves nothing for the rest of the Workspace, and it is academic anyway because those plans have no Call webhook action to spend them on.
- **No.** Not true on that one. Free Forever and Unlimited and Core are both listed as not having task webhooks. Free gets 100 Actions a month. The API stays at 100 requests a minute per token on Free, Unlimited and Business alike, and conditions are unavailable below Business.

Counted off that grid, of twenty pairings: eleven give you yes, one gives you just, eight give you no.

The third row is the sentence this grid exists for: on Business you get the webhook, the Actions and the conditions, and you are still on the same 100 requests a minute as somebody on the free plan. So the upgrade that makes this build possible is not the upgrade that makes it fast, and a backfill of any size on Business is a scheduling exercise rather than a job you start and watch.

## What actually syncs

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

| What | Direction | What that means in practice |
|---|---|---|
| The trigger | One way, out | A Call webhook automation on a task change, sending the payload to your endpoint with headers you set. |
| The lookup | One way, out | POST /v2/enrich/persons from your middle layer. 2 credits on a match, nothing on an error. |
| The write-back | One way, in | The ClickUp API sets the custom fields on the task, against 100 requests a minute on most plans. |
| The status change | One way, in | Move the task when the lookup resolves, so an unenriched task is visible rather than merely unchanged. |

## Which field lands where

A person in ClickUp is a task, so the field map is a task map. The useful part is not which value goes where, which is obvious, but which leg of the journey each value travels on, because the trip out and the trip back use different machinery.

| In ClickUp | In Reverse Contact | What to know about the match |
|---|---|---|
| An email on the task, in a custom field | The Call webhook payload | ClickUp sends information about the task that triggered the automation. Dynamic variables such as the task ID can go in the URL, which is how your endpoint knows what to write back to. |
| That email | POST /v2/enrich/persons, 2 credits | Identity, the current role and the company behind it on one schema. A miss returns null with a confidence score and costs nothing. |
| A company domain | POST /v2/enrich/companies, 2 credits | Firmographics from a domain. Run it against the account task rather than once per person attached to it. |
| A profile URL already on the task | POST /v2/fetch/persons, 1 credit | Half the price, and unmetered from the $249 plan rather than the $699 one. Worth checking for before paying for a reverse lookup. |
| currentPosition.title | A text or dropdown custom field | A dropdown if you intend to filter or group on it, because a free-text title is unfilterable in practice once a few hundred variants arrive. |
| currentPosition.companyName | A comparison, then a field | Compare it against the account the task is filed under before writing it. A disagreement means the person has moved, which is the most useful thing this response carries. |
| metadata.updatedAt | A date custom field | Store it and the next sweep can skip everything refreshed recently instead of paying to resolve it again. |
| The resolved values | The ClickUp API, as a separate call | Not a return value from the automation. The webhook is outbound only, so the write is a new request against 100 a minute on most plans. |

### The round trip, and the leg ClickUp cannot do

ClickUp describes its webhooks as sending information proactively rather than requesting it, and that single sentence is why this build has four legs instead of two. Each row below is one leg and where it has to run, which is the thing to get straight before anybody opens a settings screen.

| The leg | Where it runs, and why there |
|---|---|
| Noticing that a task needs enriching | ClickUp, and this is what it is good at. A Call webhook automation fires on the exact task change you name, which is the part that is awkward everywhere else |
| Sending the identifier out | ClickUp, from Business upwards. Headers and URL parameters are yours to set, so the credential travels properly |
| Doing the lookup | Your middle layer. There is no step inside ClickUp that calls Reverse Contact, and no app on either side that supplies one |
| Getting the answer back onto the task | The ClickUp API, as a fresh request. This is the leg people assume ClickUp provides and it does not: the automation has no documented way to read the response |
| Starting an automation from outside | ClickUp's Webhook received trigger, which exists but is a second automation rather than a reply to the first |
| Knowing it worked | A status change you write yourself. Automations history is one day on Business, so the task has to carry its own evidence |

**What does not cross:**

- An app inside ClickUp. ClickUp lists no Reverse Contact integration and Reverse Contact publishes apps on Clay, Zapier and Make and nothing inside any CRM, sequencer or work management tool.
- A reply the automation can read. The Call webhook action sends a payload; nothing documented brings the response back into the automation or into a field.
- A business email or a direct phone number. Both are separate endpoints at 3 and 20 credits, charged only when one is found, and both are asynchronous, which an automation cannot wait for.
- The live endpoints. A live job is documented as aiming for under 15 seconds and possibly taking tens of minutes, and nothing in a ClickUp automation waits for that.

## Connect it, in this order

**Who has to do it:** A ClickUp Workspace admin or owner to activate the Automations ClickApp, plus whoever hosts the middle layer and whoever can create a Reverse Contact API key.
**How long:** An afternoon on Business or above. Longer if the plan has to be upgraded first.

### 1. Check the plan before designing anything, because this one gate decides everything

*Where:* ClickUp: Settings > Plan

Task webhooks are unavailable on Free Forever and on Unlimited and Core. There is no configuration, no workaround inside the product and no partial version: either the Call webhook action is there or this build has to happen before the task is created instead.

### 2. Activate the Automations ClickApp

*Where:* ClickUp: ClickApps, as an admin or owner

Automations have to be switched on at Workspace level by an admin or an owner before anybody can create one. Guests cannot create Automations at all, and limited members can only do so where they already have edit permissions on the location.

### 3. Decide which custom fields the enrichment owns

*Where:* ClickUp: Custom Fields on the List

Use fields the enrichment owns outright rather than ones a person edits between calls. Remember that a custom field has to be added to each List or Space you want to combine it in, so decide the scope now rather than after the first dashboard comes back half empty.

### 4. Create the webhook and put the key in a header

*Where:* ClickUp: Manage Automations > Webhooks

Custom headers take an Authorization value, which is where the credential belongs, because a URL parameter ends up in a log. Note before you save that ClickUp will not show you the header value again, so record which key went in somewhere you trust.

### 5. Test the webhook with the button, on a List that holds nothing real

*Where:* ClickUp: Test webhook

The Test webhook button sends an example payload, which is enough to confirm the endpoint, the headers and the shape. Point the first one at a request bin rather than at the enrichment, so that a mistake costs nothing and tells you more.

### 6. 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 backfill spends 2 credits only where the answer is genuinely missing. Every 4xx and 5xx costs nothing either, which means a miss on a thin list is free on the Reverse Contact side even though it still spends a ClickUp Action.

### 7. Write back through the API, and pace it for 100 a minute

*Where:* ClickUp: the public API, with a personal or OAuth token

The write is a separate call rather than a return value, and on Business the ceiling is 100 requests a minute per token. Read X-RateLimit-Remaining rather than assuming the number, because the limit depends on the plan of the Workspace hosting the token rather than on your own.

### 8. Move the task when the lookup resolves

*Where:* ClickUp: a status, not just a field

A task whose enrichment silently failed looks exactly like one that was never triggered, because an empty custom field is the default state. A status change makes the difference visible to a human, which is the only monitoring this build gets on a plan with one day of Automations history.

### 9. Run a hundred tasks and then read your Action usage

*Where:* ClickUp: Automations usage

Actions are the meter that will actually bite, because exceeding them pauses every Automation in the Workspace rather than just this one. A hundred-task pass tells you the real cost per enriched record in Actions, and that number against the monthly allowance is the answer to whether a backfill is possible at all.

The first step is the only one that cannot be worked around, and it is a billing decision rather than a technical one. Everything after it is ordinary, with the single oddity that the answer comes back by a different road than it left by, which is the thing to hold in mind when something stops working.

## How to check it worked

- Trigger the automation on one task and watch the request arrive at your endpoint. Confirm the header is there, because this is the last moment you can read it.
- Let one lookup fail on purpose, by sending an address that cannot resolve. The task should end up in a status that says so rather than sitting with an empty field, which is indistinguishable from never having run.
- Write 150 fields in a minute through the API, deliberately. The 429 and its X-RateLimit-Reset tell you what your real backfill rate is, and on Business that figure is 100 a minute whatever the plan above it offers.
- Check the Automations usage page after the test pass and multiply. If a hundred tasks cost a hundred Actions, a Business workspace has 10,000 a month for everything it does, not just for this.

## 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 Call webhook action is not in the list | Task webhooks are listed as unavailable on Free Forever and on Unlimited and Core. | Check the plan rather than the permissions. There is no setting that adds it, so the options are Business or enriching before the task is created, which a Zap or a Make scenario on the inbound form does without any ClickUp gate. |
| Every Automation in the Workspace stopped at once | The monthly Action allowance was exceeded, and ClickUp pauses the Workspace's Automations for the rest of the month rather than throttling the one that ran hot. | Route the 90% email that goes to owners and admins somewhere people read, and count Actions per enriched record before a backfill. Actions reset on the first of the month, PST. |
| The enrichment ran and the custom field is still empty | The automation sent the payload and nothing wrote the answer back. The Call webhook action has no documented way to read the HTTP response. | Add the write as a separate ClickUp API call keyed on the task ID, which is why the task ID belongs in the webhook URL as a dynamic variable. There is no version of this where the automation returns the value. |
| A 429 from ClickUp halfway through a backfill | The API allows 100 requests a minute per token on Free, Unlimited and Business, and the limit follows the plan of the Workspace hosting the token. | Honour X-RateLimit-Reset, which is a Unix timestamp, and read X-RateLimit-Limit rather than hard-coding a number that changes with somebody else's plan. |
| Nobody can tell which API key the webhook is using | ClickUp states that URL headers are sensitive and that once saved the values cannot be viewed to edit them. | Keep the record outside ClickUp, and rotate by replacing the header rather than inspecting it. Treat the saved header as write-only from the moment you click save. |
| The dashboard shows the enriched field for one List only | A custom field has to be added to the other Spaces and Lists before data from them can be combined in a single card. | Decide the field scope when you create it, not when the first report is due. This is a modelling decision in ClickUp rather than a reporting one. |
| A task that failed on Friday cannot be diagnosed on Monday | Automations usage history is one day on Free, Unlimited, Core and Business, and 30 days only from Business Plus. | Make the task carry its own evidence: a status for enriched, a status for tried and unresolved, and a date field for when. The record outlives the log on every plan this build runs on. |
| Everything stopped, including the calls that were free | Below 2 Reverse Contact credits the free Check endpoints are paused as well and answer 402 NO_CREDITS. | Watch quotas.workspace.credits.left on every response and check GET /v2/usage on a schedule, because it keeps answering when the lookups do not. Note that the automation still spends a ClickUp Action either way. |

## What breaks, from the vendors' own docs

- **Task webhooks start at Business.** ClickUp lists task webhooks, Automations integrations and Chat webhooks as unavailable on Free Forever and on Unlimited and Core, and available from Business. Every plan can use Automations; what the lower plans cannot do is send anything to a URL you choose.
- **The API is 100 requests a minute until Business Plus.** Limits are per token and depend on the plan of the Workspace hosting the token: 100 a minute on Free, Unlimited and Business, 1,000 on Business Plus, 10,000 on Enterprise and Enterprise Plus. A 429 carries X-RateLimit-Limit, X-RateLimit-Remaining and X-RateLimit-Reset as a Unix timestamp.
- **Exceed the Action allowance and Automations stop for the month.** Actions are 100 a month on Free, 1,000 on Unlimited and Core, 10,000 on Business, and 25,000 or 100,000 on Business Plus depending on whether the plan is an old one or a new one. They reset on the first of the month, PST, and when the limit is passed ClickUp pauses the Workspace's Automations until it resets.
- **One trigger, fifteen conditions, six actions.** That is the shape of a single automation, and conditions are themselves a Business feature. It is enough for this build and it is worth knowing before designing something that branches, because the branch has to live in your middle layer instead.
- **A saved header cannot be read back.** ClickUp says URL headers are sensitive and that once they are saved you cannot view the values to edit them. That is good security and poor operations: there is no way to confirm which key is in there, so rotating one means replacing the header rather than checking it.
- **Usage history is one day on Business.** ClickUp stores one day of Automations activity on Free, Unlimited, Core and Business, 30 days on Business Plus and six months on Enterprise. An enrichment that failed on Friday is not diagnosable on Monday at the plan this build needs.
- **Under 2 credits the free checks stop too.** Below 2 Reverse Contact credits even the free check endpoints answer 402 NO_CREDITS. The automation still fires and still spends an Action, so the cost lands on the ClickUp side while nothing is enriched.

## The APIs, if you are building around it instead

### ClickUp

- **Base:** `https://api.clickup.com/api/v2`
- **Auth:** `Authorization: pk_...` (personal token) or OAuth.

| Call | Request | What it does |
|---|---|---|
| `POST /list/{list_id}/task` | `{ "name": "...", "description": "...", "custom_fields": [...] }` | Create a task. Use this only if the native HubSpot action does not cover your fields. |
| `ACTION ClickUp action inside a HubSpot workflow` | - | The native path, and the one to prefer. Both vendors built into the other, so both directions are first-class. |

**Rules that will cost you time if you skip them:**

- The native integration covers common objects well and **thins out at custom fields**. Workflows that depend on custom fields usually move to Make.
- One rule per direction. HubSpot owns "a deal changed, create or update work"; ClickUp owns "work changed, update the deal". Writing to the same field from both sides is a loop.

Docs: https://developer.clickup.com/

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

- ClickUp API: rate limits: https://developer.clickup.com/docs/rate-limits
- ClickUp: create a task webhook Automation: https://help.clickup.com/hc/en-us/articles/31126817112343-Create-a-task-webhook-Automation
- ClickUp: integrate ClickUp using Automation webhooks: https://help.clickup.com/hc/en-us/articles/35313844961943-Integrate-ClickUp-using-Automation-webhooks
- ClickUp: Automations feature availability and limits: https://help.clickup.com/hc/en-us/articles/23477062949911-Automations-feature-availability-and-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/clickup-integrations/clickup-reverse-contact-integration#reddit
- This pair, with the reasoning behind each step: https://www.reversecontact.com/integrations-hub/clickup-integrations/clickup-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.*
