---
name: hubspot-speed-to-lead
description: Build an inbound speed-to-lead pipeline: a HubSpot form submission enriched by Reverse Contact, scored and routed on the enriched fields, and announced to a named owner in Slack inside a minute. Use when the user wants to enrich inbound leads on creation, route on firmographics rather than on form fields, or cut time to first touch.
---

# Inbound speed to lead

> Generated from https://www.reversecontact.com/integrations-hub/workflows/inbound-speed-to-lead
> Every tier requirement and limit below was read from the vendor's own documentation on 2026-09-18.
> Vendors change these without notice. Re-check anything load-bearing before you rely on it.

**Tools in this workflow:** HubSpot, Reverse Contact, Slack.
**Build effort:** Hours.

## What you are building

A form submission creates a HubSpot contact. Within a minute that record carries a title, a seniority, a company size and a score; an owner has been assigned from those fields rather than from a dropdown the visitor guessed at; and the right person has a Slack message naming them and telling them what to do.

## Ask this before writing anything

Does the account have **HubSpot Data Hub Professional or Enterprise**? Calling an external API from a workflow needs the webhook action or the custom code action, and both live in Data Hub rather than Sales Hub. If yes, build route A entirely inside HubSpot. If no, build route B in n8n. Do not recommend a hub upgrade to avoid a middle layer: it costs far more than n8n does. If you cannot find out, build route B, because it works either way.

## Prerequisites

| What | Where to get it | Notes |
|---|---|---|
| Reverse Contact API key | Workspace > API Keys, after signing up | The free trial and the 500 credits a new account starts with cover building and testing this end to end |
| HubSpot private app token | Settings > Integrations > Private Apps | Scopes: crm.objects.contacts.read and .write |
| HubSpot Data Hub Pro (route A only) | An existing subscription | If absent, use route B |
| A HubSpot developer account (route B only) | developers.hubspot.com | The n8n HubSpot Trigger needs a developer API key, not a private app token |
| Slack bot token | A Slack app with chat:write | chat:write.public too, if the bot will not be invited to the channel |

## The tools, and how to call them

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

### HubSpot

- **Base:** `https://api.hubapi.com`
- **Auth:** `Authorization: Bearer <private-app-token>` for a private app, or OAuth for a marketplace app. Full CRM API access is on every tier including Free.

| Call | Request | What it does |
|---|---|---|
| `PATCH /crm/v3/objects/contacts/{contactId}` | `{ "properties": { "rc_title": "VP Sales" } }` | Update a contact. Send only the properties you own. |
| `POST /crm/v3/objects/contacts/search` | `{ "filterGroups": [...], "properties": [...] }` | Find records by property. Use this to pull the slice that is missing a field. |
| `POST /crm/v3/objects/contacts/batch/update` | `{ "inputs": [ { "id": "...", "properties": {...} } ] }` | Batch of up to 100. Prefer this over per-record PATCH at volume: it is one request against the rate limit. |

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

- **Rate limits.** A private app gets 190 requests per 10 seconds on Professional and Enterprise, 100 on Free and Starter. Daily caps are 250,000 / 625,000 / 1,000,000 calls **per account, shared across every app**. A public OAuth marketplace app is capped at 110 per 10 seconds per installing account.
- **Calling an external API from a workflow needs Data Hub Professional or Enterprise.** Both the webhook action and the custom code action live in that hub, not in Sales Hub. Check this before designing an in-HubSpot build.
- **Custom code actions get 20 seconds and 128 MB.** Combined length of all workflow secrets is capped at 1,000 characters. Secrets are read with `process.env.NAME`.
- **Workflows:** up to 50 simple on Starter, up to 300 fully customisable on Professional.
- **Never write to a property a human maintains.** Use prefixed properties (`rc_*`) and promote with a separate workflow only where the human field is empty.

**HubSpot custom code action (Node 20):**

```javascript
// Input field: email   Output fields: rc_status, rc_title, rc_company, rc_headcount
// Secret: RC_API_KEY
const axios = require('axios');

exports.main = async (event, callback) => {
  const email = event.inputFields['email'];
  const res = await axios.post(
    'https://api.reversecontact.com/v2/enrich/persons',
    { email },
    { headers: { Authorization: `Bearer ${process.env.RC_API_KEY}` } }
  );

  const person = res.data?.data?.person;
  const company = res.data?.data?.company;

  // null means "not found", not "try harder". Write nothing and flag it.
  if (!person) return callback({ outputFields: { rc_status: 'no_match' } });

  callback({ outputFields: {
    rc_status:    'matched',
    rc_title:     person.currentPosition?.title || '',
    rc_company:   company?.name || '',
    rc_headcount: company?.employeeCount || 0
  }});
};
```

Docs: https://developers.hubspot.com/docs/api/overview

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

### n8n

- **Base:** `Self-hosted or n8n Cloud`
- **Auth:** Credentials are stored in n8n, not in the workflow JSON, so the workflow stays safe to export and review.

| Call | Request | What it does |
|---|---|---|
| `NODE HTTP Request` | `Authentication: Generic > Header Auth. Name: Authorization. Value: Bearer rc_your_api_key` | There is no dedicated Reverse Contact node and you do not need one. Five minutes to configure, and no node update can break it. |
| `NODE HubSpot Trigger` | - | Authenticates with a **developer API key from a HubSpot developer account**, not a private app token, because that is how HubSpot exposes the webhooks API. Free to create, and nobody expects it. |
| `NODE Wait + IF` | - | The polling loop for Reverse Contact's /live endpoints: Wait 5s, GET the webhook id, IF status != succeeded loop back. |

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

- HubSpot allows **one webhook URL per app**. Route several object types through one subscription and branch inside n8n with a Switch node.
- Self-hosting is usually the reason this route was chosen: records never leave infrastructure you control. Do not quietly move it to a third-party cloud.
- n8n must be reachable by HubSpot for webhook triggers to fire.

Docs: https://docs.n8n.io/integrations/builtin/core-nodes/n8n-nodes-base.httprequest

## Build it

### 1. Create the properties before anything writes

In HubSpot, create `rc_status`, `rc_title`, `rc_company`, `rc_headcount`. Prefixed, and nobody types into them. Do not map enrichment onto the fields reps maintain: that is the single most common way this pipeline gets switched off in month three.

### 2. Route A: the custom code action

Build a contact-based workflow triggered on form submission, add a custom code action with `email` as an input field and the four `rc_*` properties as output fields, and store the key as the workflow secret `RC_API_KEY`. The code is in the HubSpot section above. Remember the 20-second and 128 MB limits: use the cached endpoint, never `/live`.

### 3. Route B: the n8n workflow

HubSpot Trigger (contact.creation) to HTTP Request (Reverse Contact) to IF (did it resolve?) to HubSpot node (update contact) to Slack node. Store the Reverse Contact key as a Header Auth credential rather than putting it in the node.

### 4. Promote, do not overwrite

A second HubSpot workflow copies `rc_title` into the title field people trust **only where that field is empty**. Same for company size. This is one extra workflow and it removes the entire class of "the robot overwrote my correction" problem.

### 5. Score and assign

Build the score from `rc_headcount` and `rc_title`, not from the form fields. That is the actual payoff: routing that does not depend on prospect honesty.

### 6. Alert, sparingly

Slack only above the score threshold, to one channel, mentioning the assigned owner by name, with the enriched context in the message and a link to the record. Do not alert on every submission.

## Gotchas

- Set the Slack threshold high. The pipeline will run for years; the channel gets muted in a month if it fires on everything, and a muted channel looks exactly like a working one.
- Decide what an unresolved lead does *before* you ship: general queue, review flag, or a second provider. If you do nothing, those leads silently score zero.
- If the traffic is heavy on personal email addresses, filter those out before the call rather than paying for a lookup that was never going to resolve.
- HubSpot's Slack workflow action cannot post to the channel associated with the record. One channel with one owner is the correct design here anyway; if somebody asks for per-segment routing later, that is an hour in n8n calling chat.postMessage.

## What breaks, from the vendors' own docs

- **The Slack message cannot follow the record.** HubSpot's Slack workflow action sends to a channel chosen at design time. There is no built-in option to send to the channel associated with the record that triggered it. For this workflow that is fine, because one channel with one owner is the correct design anyway. It becomes a problem the moment somebody asks for per-segment routing, and at that point it is an hour of work in n8n rather than a setting.
- **Enrichment on creation writes to your CRM.** This is the whole point and it is also the risk. Anything pointed at a property a human maintains will eventually overwrite something correct with something plausible. The prefix convention and a promote-only-if-empty workflow cost an afternoon and remove the entire class of problem.
- **A miss is a real outcome, so handle it.** Reverse Contact returns null with a confidence score rather than a best guess, which is the behaviour you want and only useful if the next step branches on it. Decide in advance what an unresolved lead does: route to a general queue, flag for review, or fall through to a second provider. Doing nothing means those leads silently score zero.
- **The alert degrades faster than the pipeline.** Enrichment will keep working for years. The Slack channel will get noisy within a month if the threshold is set generously, and a muted channel looks exactly like a working one from the admin screen. Set the threshold high, review it once a quarter, and send everything below it to a digest.

## How to verify it works

- Submit a test form with a work email you can verify by hand. Open the contact and confirm only `rc_*` properties changed.
- Submit one with a personal address that will not resolve. Confirm `rc_status` is `no_match`, nothing else was written, and the lead still routed somewhere.
- Check `quotas.workspace.credits.left` in the response and log it, so the balance is never a surprise.
- Time it: form submission to Slack message should be under a minute. If it is not, the enrichment call is not the slow part, the trigger is.
- After a week, count the share of submissions that resolved. That is your real match rate on your real traffic, and it is the only number that predicts the bill.

## What this costs to run

| Component | Route A | Route B | Notes |
|---|---|---|---|
| HubSpot | Data Hub Pro | Any tier | Route A needs the webhook or custom code action, which is Data Hub. Route B only needs a developer app, which is free. |
| Orchestration | None needed | n8n, free self-hosted | Route A has no middle layer. Route B adds an instance you host and own. |
| Reverse Contact | Credits | Credits | 2 credits a reverse lookup from an email, published. Packs from $100, valid 3 months, or an Unlimited plan from $249 a month. |
| Slack | Free plan works | Free plan works | One channel and one message type does not need a paid workspace. |

The credit cost is published and the dollar cost is not, so this table stops where their pricing page does. A reverse lookup from an email is 2 credits and a freshness check is free. What a credit costs depends on the pack or the plan it came from, and a modelled figure here would be a guess wearing a decimal point. Worth sizing against monthly form volume rather than database size, because the first is a much smaller number: above roughly 15,000 lookups a month their own page points you at an Unlimited plan, where the cached endpoints stop being metered.

## Sources

- Reverse Contact: https://docs.reversecontact.com/getting-started
- HubSpot: https://developers.hubspot.com/docs/api/overview
- Slack: https://api.slack.com/methods/chat.postMessage
- n8n: https://docs.n8n.io/integrations/builtin/core-nodes/n8n-nodes-base.httprequest
- This workflow, with the reasoning behind each step: https://www.reversecontact.com/integrations-hub/workflows/inbound-speed-to-lead

---

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