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

# Slack and Reverse Contact

> Generated from https://www.reversecontact.com/integrations-hub/slack-integrations/slack-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 Reverse Contact API key, somewhere to run the lookup, and a Slack app or an incoming webhook

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

## The short version

Slack is where the answer is delivered and never where the lookup happens. Nothing in Workflow Builder sends a request to an arbitrary URL, so the work runs in Clay, n8n, Zapier, Make or a custom step you host, and Slack receives a message. That is a smaller claim than most pages here make and it is the whole of this one: get the routing and the volume right, because the enrichment is somebody else's job.

## Which of these tools can call an API from inside itself

Rows: The surface. Columns: What it can do. The reason this page sends the lookup somewhere else is not Slack being limited; it is that most of the tools people sit in all day cannot make an outbound request and read the answer. Every figure below is from the vendor's own documentation, and the column that matters is the second one, because sending a request without reading the reply is half an integration.

| The surface | Send an identifier out | Read the answer back in | Works without a plan upgrade | Can wait for an async job |
|---|---|---|---|---|
| Slack: built-in Workflow Builder steps | No | No | No | No |
| Slack: a custom step you build and host | Yes | Yes | No | Partly |
| ClickUp: the Call webhook automation | Yes | No | No | No |
| Google Sheets: Apps Script | Yes | Yes | Yes | Partly |
| Gong: nothing in product, the API only | No | No | No | No |

- **Yes.** Documented and unambiguous. A Slack custom step finishes by calling functions.completeSuccess with its outputs, so the answer reaches the next step; Apps Script has UrlFetchApp and returns the response to the sheet; ClickUp's Call webhook sends a payload to a URL you choose with headers you set.
- **Partly.** True with a condition, and the condition is time. A custom step is your own hosted code, so it can poll before it completes, but Slack expects it to finish. Apps Script gets 30 seconds inside a custom function and 6 minutes inside a script, which covers a 500ms lookup and rules out a live job documented as possibly taking tens of minutes.
- **No.** Not true on that one. Slack documents no built-in step that calls an arbitrary URL, and says custom steps cannot be developed on a Free plan while Workflow Builder itself is on paid plans. ClickUp's webhook is outbound only and task webhooks start at the Business plan. Gong has no in-product step at all, which is why its page is an API page.

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

The bottom row and the top row agree, which is the finding: the two tools in this directory that people spend the most time looking at are the two that cannot fetch anything. More uncomfortably, the only surface here that can send a request, read the reply and do it without an upgrade is a spreadsheet, which is a poor argument for building anything important in a spreadsheet and a very good explanation of why so many teams do.

## What actually syncs

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

| What | Direction | What that means in practice |
|---|---|---|
| The ask | One way, out | A workflow link, a slash command or a webhook trigger carries an email or a domain out of Slack. |
| The lookup | One way, out | POST /v2/enrich/persons in the orchestrator or the custom step. 2 credits on a match, nothing on an error. |
| The answer | One way, in | chat.postMessage or an incoming webhook, one message per second per channel. |
| The routing | One way, in | Which channel it lands in, decided by what came back rather than by who asked. |

## Which field lands where

There is nothing to map, because Slack holds no record to map onto. What matters instead is which part of the response earns a line in a message somebody reads in two seconds, and which part belongs in the system that stores it.

| In Slack | In Reverse Contact | What to know about the match |
|---|---|---|
| An email typed into a workflow or slash command | 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, because every 4xx and 5xx is free. |
| A domain from an inbound signup | POST /v2/enrich/companies, 2 credits | Firmographics from a domain. Run it once per account rather than once per person who signs up from it. |
| A profile URL somebody pasted in a channel | POST /v2/fetch/persons, 1 credit | Half the price of a reverse lookup, and unmetered from the $249 plan rather than the $699 one. Pasting a profile link into Slack is a common enough habit to build on. |
| currentPosition.title and companyName | The first line of the message | The two values that decide whether a person reads any further. Everything else is detail that belongs behind a link. |
| The confidence score | Whether to post at all | A thin match is a judgement, and the judgement is better made by your rule than by whoever happens to read the channel. |
| The whole record | The CRM, not the channel | Slack stores nothing you can query later. If the answer is worth keeping, it has to be written somewhere that is not a message. |
| The message itself | chat.postMessage, or an incoming webhook | One per second per channel either way. Bursts are tolerated and sustained excess shows the reader an error the sender never sees. |
| Anything outbound to Reverse Contact | Only the identifier you send | This is a read layer. No message, channel or member is sent anywhere, and there is nothing in the product to send it to. |

### What earns a line in the message, and what does not

A Slack message is read in about two seconds and then scrolled past, so the schema is not the thing to print. Each row below is a field the response actually carries, judged only on whether it helps the person in the channel decide what to do next.

| In the response | Whether it earns a line |
|---|---|
| currentPosition.title and companyName | Yes, and they are the first line. These two decide whether this is worth anybody's attention, and burying them under a header defeats the message |
| data is null, with a confidence score | Yes. Say the lookup did not resolve rather than posting nothing, because a silent channel reads as a broken integration and nobody reports it |
| isInRemembrance | Yes, and it should stop whatever was going to happen next. This is the one field on the schema where a cheerful alert would be unforgivable |
| currentPosition.companyName against the account you hold | Yes, when they disagree. A job change is the most actionable thing this response carries and it is found by comparing two values rather than reading one |
| Education, skills and the full position history | No. All useful, none of it a reason to interrupt somebody, and all of it available on the record behind the link |
| hasVerificationBadge and followersCount | No. They read as seniority and they are not, which is worse in a channel than on a record because nobody will check |

**What does not cross:**

- An app inside Slack. There is no Reverse Contact listing on the Slack Marketplace, which is consistent with apps on Clay, Zapier and Make and nothing inside any CRM, sequencer or collaboration tool.
- A built-in Workflow Builder step that calls an arbitrary URL. Slack documents connector steps for supported third parties and custom steps you build yourself, and nothing in between.
- 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 a Slack message is a poor shape for.
- Anything stored. A channel is not a datastore, and an enrichment that lives only in a message has to be paid for again the next time somebody asks.

## Connect it, in this order

**Who has to do it:** Somebody who can add an app or an incoming webhook to the workspace, plus whoever owns the orchestrator and whoever can create a Reverse Contact API key.
**How long:** An afternoon for the orchestrator route. A week for a custom step, most of it review.

### 1. Decide which channel, and who is accountable for it

*Where:* Your own process, not a settings screen

An alert that names no owner is a notification, and a channel that fires often enough gets muted by everybody in it. Pick the channel before the trigger, name the person who acts on it, and accept that this decision is worth more than every technical choice below it.

### 2. Decide whether the lookup runs outside Slack or inside it

*Where:* Your own architecture

Outside means an orchestrator calls Reverse Contact and posts the result, works on any Slack plan, and is an afternoon. Inside means a custom step built with the Deno Slack SDK or Bolt, needs a paid plan and an org-ready app, and is the only way the answer reaches the next workflow step instead of a human.

### 3. Create the Reverse Contact API key and check a balance call first

*Where:* Reverse Contact: Workspace > API Keys

The trial takes no card and a new account starts with 500 credits, which is 250 reverse lookups and more than enough to find your own match rate. It runs until those credits are spent rather than for a number of days. GET /v2/usage keeps answering whatever the balance, which makes it the right thing for a bot to check on a schedule.

### 4. Add the incoming webhook or the app, and keep the key out of the URL

*Where:* Slack: your app's configuration

An incoming webhook URL is itself a secret and belongs wherever your orchestrator keeps secrets. The Reverse Contact key travels in an Authorization header and never in a query string, because a URL is the thing that ends up in a log.

### 5. 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 actually missing. On a channel that posts every inbound signup this is the difference between a budget and a surprise.

### 6. Write the message so the first line is the decision

*Where:* Your orchestrator, or the custom step

A person reads a Slack message in about two seconds and the useful content is almost never the whole record. Lead with the one thing that decides what happens next, put the rest behind a link to the record, and resist the temptation to print the schema because it is available.

### 7. Decide what an unresolved lookup posts

*Where:* Your orchestrator

Reverse Contact returns null with a confidence score rather than a guess, so a miss is a branch rather than an error. Posting nothing is usually wrong, because silence reads as the integration being broken; posting the identifier and saying it did not resolve is honest and keeps the channel trustworthy.

### 8. Count the messages for a week before adding a second trigger

*Where:* The channel itself

The volume question is the one that kills these integrations and it is answerable by looking. If the channel is already firing more often than anybody reads it, a second trigger makes the first one worthless rather than making the channel more useful.

Only the first step cannot be undone cheaply, and it is the one with no screen attached: a channel that has been muted stays muted long after the routing is fixed. The rest is ordinary plumbing, and the choice in step two is the one that decides whether this is an afternoon or a project.

## How to check it worked

- Post a real lookup into the channel and then ask the person who owns it what they would do next. If the answer is not obvious from the first line of the message, the message is wrong rather than the data.
- Fire the webhook trigger eleven times inside a minute, deliberately. The eleventh should be refused, and knowing what your workflow does when it is refused is better learned now than during a launch.
- 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 that is the cheapest thing to learn on one record.
- Turn the orchestrator off and watch the channel. Nothing should appear, and if something still does, there is a second path posting to that channel that nobody remembered.

## 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 channel went quiet and nobody noticed for a fortnight | A silent integration and a working integration look identical in Slack, because the absence of a message is not an event. | Post a heartbeat on a schedule, or have the orchestrator post its own failures to the same channel. A channel that has never told you it is broken has not proved it is working. |
| Everybody muted the channel | The trigger was too broad, so the channel fired more often than anyone could read, which is the failure mode of every integration on the Slack hub. | Narrow the trigger rather than the message. One event type, one channel, one named owner, and move everything else to a report nobody has to read in real time. |
| The eleventh lookup in a minute did nothing | Workflow webhook triggers are limited to 10 per minute, and the eleventh is refused rather than queued. | Move the busy case to a scheduled sweep and keep the on-demand trigger for the occasional question. If people genuinely need to ask eleven times a minute, the answer belongs on the record rather than in a channel. |
| Messages stopped appearing in one busy channel but not the others | Posting is limited to one message a second per channel, by chat.postMessage and incoming webhooks alike, and sustained excess is throttled. | Batch into one message rather than posting a line at a time, which is better for the reader as well. Slack shows the reader an error about undisplayed messages that the sending app never sees, so watch the channel rather than the logs. |
| The app could suddenly only read fifteen messages at a time | conversations.history and conversations.replies moved from Tier 3 to Tier 1 for commercially distributed apps that are not Marketplace approved, with a maximum of 15 objects and one request a minute. | If this is your own app for your own workspace it is an internal customer-built app and is explicitly unaffected, so check how it was registered before rewriting anything. If it is genuinely distributed, Marketplace approval is the documented route back. |
| A custom step will not install | Apps carrying workflow steps have to be org-ready, and custom steps cannot be developed on a Free plan. | Confirm the plan and the org-readiness before building, not after. Where neither is available, the orchestrator route reaches the same channel with none of these conditions. |
| A beautifully formatted message about somebody who left the company | The enrichment returned a current employer and nothing compared it with the account the alert was about. | Compare currentPosition.companyName against what you already hold and say so when they disagree. It is the highest-value check on the response and it is two values rather than a new field. |
| 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, because the fetch a check precedes can itself cost 2. | Watch quotas.workspace.credits.left, which rides on every response, and check GET /v2/usage on a schedule because it keeps answering whatever the balance. |

## What breaks, from the vendors' own docs

- **Workflow webhook triggers are 10 a minute.** This is the ceiling on enrich on demand and it is low. Event triggers get 10,000 an hour and the Events API gets 30,000 deliveries per workspace per app per 60 minutes, so a sweep is fine and a team typing lookups all morning is not. Design the busy case as a scheduled pass rather than as a queue of trigger calls.
- **Posting is one message a second, per channel.** The same figure whether you use chat.postMessage, an incoming webhook or anything else, with short bursts tolerated. Slack says that if an app keeps exceeding its allowance, users see an error telling them some messages are not being displayed, which is a failure the sender never sees.
- **Every Slack plan gets the same rate limits.** The four web API tiers are 1+, 20+, 50+ and 100+ requests a minute per method per workspace, and nothing in the documentation makes them depend on what you pay. The plan decides whether you can build inside Slack at all; it does not buy throughput.
- **Reading channel history is now a question about your app, not your plan.** Since 29 May 2025, conversations.history and conversations.replies drop to one request a minute and 15 objects for commercially distributed apps that are not Marketplace approved. Internal customer-built apps are explicitly unaffected and keep 50+ a minute and 1,000 objects, so a Slack app your own team builds for your own workspace is the exempt case.
- **Under 2 credits the free checks stop too.** When the Reverse Contact workspace has fewer than 2 credits left, even the free check endpoints answer 402 NO_CREDITS. A bot that checks cheaply before spending fails at the check, and in a channel that reads as the bot being broken rather than as a billing problem.

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

### Slack

- **Base:** `https://slack.com/api`
- **Auth:** `Authorization: Bearer xoxb-...` (bot token). Scope `chat:write`, plus `chat:write.public` to post to a channel the bot has not joined.

| Call | Request | What it does |
|---|---|---|
| `POST /api/chat.postMessage` | `{ "channel": "C0123", "text": "...", "blocks": [...] }` | The only call most of these workflows need. Use this when you need to choose the channel at runtime. |

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

- **HubSpot's Slack workflow action cannot route to the channel associated with the record.** It sends to a channel chosen at design time. If you need per-record routing, look the association up yourself and call `chat.postMessage` directly.
- Creating a Slack channel from a HubSpot workflow requires HubSpot Professional or Enterprise.
- Route only events a named human must act on within minutes. A channel that fires forty times a day gets muted, and a muted channel is indistinguishable from a working one in the admin screen.

Docs: https://api.slack.com/methods/chat.postMessage

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

- Slack: web API rate limits: https://docs.slack.dev/apis/web-api/rate-limits/
- Slack: rate limit changes for non-Marketplace apps: https://docs.slack.dev/changelog/2025/05/29/rate-limit-changes-for-non-marketplace-apps/
- Slack: workflows and custom steps: https://docs.slack.dev/workflows/
- Slack: workflow steps: https://docs.slack.dev/workflows/workflow-steps/
- Slack: guide to Slack Workflow Builder: https://slack.com/help/articles/360035692513-Guide-to-Slack-Workflow-Builder
- Slack: sending messages using incoming webhooks: https://docs.slack.dev/messaging/sending-messages-using-incoming-webhooks/
- ClickUp: create a task webhook Automation: https://help.clickup.com/hc/en-us/articles/31126817112343-Create-a-task-webhook-Automation
- Google Apps Script: quotas for Google Services: https://developers.google.com/apps-script/guides/services/quotas
- Gong: what the Gong API provides: https://help.gong.io/docs/what-the-gong-api-provides
- 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/slack-integrations/slack-reverse-contact-integration#reddit
- This pair, with the reasoning behind each step: https://www.reversecontact.com/integrations-hub/slack-integrations/slack-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.*
