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

# Smartlead and Reverse Contact

> Generated from https://www.reversecontact.com/integrations-hub/reverse-contact-integrations/smartlead-reverse-contact-integration
> Every tier requirement, sync direction and limit below was read from the vendors' own documentation on 2026-10-11.
> 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 and a Smartlead API key, used server side

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

## The short version

Smartlead is the most API-complete sequencer at its price, and the enrichment build is the standard shape: enrich the row, then upload it, rather than uploading and fixing afterwards. Two details set it apart. The key travels in the query string rather than a header, which is a real operational constraint on where the calls can run. And the hourly limit of 1,000 on Standard, rather than the per-minute figure, is what caps a bulk pass.

## What the Smartlead limits let you move in an hour

Rows: Smartlead plan. Columns: What you are trying to do. Smartlead meters per API key across every endpoint combined, and publishes three figures for each plan: a per-second burst, a per-minute limit and a per-hour limit. The hourly one is what caps a bulk pass, and it is the figure people do not look at until a pass stops halfway.

| Smartlead plan | Upload a few hundred enriched leads | Upload two thousand in one sitting | Loop over the three tight endpoints | Poll campaign state while uploading |
|---|---|---|---|---|
| Standard: 10 a second, 60 a minute, 1,000 an hour | Fits | No | No | Tight |
| Pro: 20 a second, 120 a minute, 3,000 an hour | Fits | Fits | No | Fits |
| Enterprise: custom on all three | Fits | Fits | No | Fits |

- **Fits.** Inside the documented ceilings with room to spare. A few hundred uploads is well under even the Standard hourly figure of 1,000, and Pro triples that to 3,000 an hour alongside 120 a minute.
- **Tight.** Possible and crowded. On Standard the whole budget is 1,000 an hour across every endpoint combined, so polling campaign state during an upload is spending the same allowance twice.
- **No.** Over the ceiling. Two thousand uploads cannot fit in a Standard hour at all, and the third column is no on every plan: leads statistics by campaign, all-leads activities and domain-wise mailbox health metrics each carry their own limit of 10 requests per 60 seconds per account, independent of the plan.

Counted off that grid, of twelve pairings: seven give you fits, one gives you tight, four give you no.

The third column is the one that does not move, and that is the finding: three endpoints are capped at 10 requests a minute per account whatever you pay, so no upgrade makes them loopable. Everything else here is an hourly arithmetic problem, which an upgrade does solve, and and which Instantly answers with 6,000 requests a minute on every workspace.

## What actually syncs

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

| What | Direction | What that means in practice |
|---|---|---|
| The list, before upload | One way, out | Enrich each row with /v2/enrich/persons from its email. 2 credits on a match, nothing on a miss or a check. |
| Lead upload | One way, in | POST the enriched leads with their custom fields, so personalisation has values to render from. |
| Reply and event webhooks | One way, out | Smartlead fires events back out, which is how a reply reaches a CRM or a Slack channel. |
| Anything back to Reverse Contact | One way, out | Nothing. This is a read layer, and your pipeline decides which custom fields get written. |

## Which field lands where

Everything happens outside Smartlead: enrich the row, then upload it. What is worth laying out is which enriched value becomes which custom field, and which parts of the response should stop a row being uploaded at all.

| In Smartlead | In Reverse Contact | What to know about the match |
|---|---|---|
| An email on the row | POST /v2/enrich/persons, 2 credits | Identity, the current role, history, education, skills and location on one schema. A confident null costs nothing, because Reverse Contact charges 0 credits on every 4xx and 5xx. |
| A company domain | POST /v2/enrich/companies, 2 credits | Firmographics from a domain or a company name. Once per company rather than once per lead at it, which is both cheaper and more consistent across a campaign. |
| A profile URL already on the row | POST /v2/fetch/persons, 1 credit | Half the credits, and unmetered from the $249 plan rather than the $699 one. Lists sourced from profiles rather than forms often already carry one. |
| currentPosition.title | A custom field, named to match the sequence | The value most openers reference. The key has to match the merge variable exactly, because a near-miss renders the fallback rather than erroring. |
| company.name and employeeCount | Custom fields on the lead | The two values that carry most first-line personalisation. Headcount is a number in the response and a string in a merge field, so decide the formatting before the upload rather than per row. |
| Add lead to campaign | The campaign has to exist first | Smartlead campaigns are built in Smartlead. The sequence, the mailboxes and the schedule are decisions taken before any of this runs, and the campaign id is what the upload is pointed at. |
| The api_key parameter | In the query string, not a header | Documented, and the reason this route is server side. URLs are logged by things you do not control, so treat the key as something that will end up in a log and rotate it accordingly. |
| Anything outbound to Reverse Contact | Only what your pipeline sends | This is a read layer. No lead, campaign or reply is sent anywhere, and there is nothing in the product to send it to. |

### The fields that should stop an upload rather than improve one

The rest of this directory treats an enrichment response as values to write. On a sender it is also a list of reasons not to send, and that half is almost never built. Each row is a documented field, and each is a row to drop rather than a row to personalise better.

| In the response | Why it is a reason not to send |
|---|---|
| isInRemembrance | The person has died. No amount of personalisation makes the email acceptable, and it is the one outbound failure that cannot be apologised for afterwards |
| currentPosition.companyName disagrees with your record | They have changed job, so a campaign written for the old role is about to reach the new one. Re-qualify rather than refresh |
| isOpenToWork | They are looking to leave. A reason for a human to read the opener once, rather than an automatic stop |
| data is null, with a confidence score | Nothing matched confidently. Sending the fallback text is a decision, and on a cold list it is usually the wrong one |
| metadata.updatedAt, from long ago | Stale rather than wrong, which is the one case where a 2-credit live refresh earns its money |
| followersCount and hasVerificationBadge | Not suppression at all. Listed because they are the fields teams reach for as a seniority proxy, and neither is one |

**What does not cross:**

- An app inside Smartlead. There is none, which is consistent with Reverse Contact maintaining apps on Clay, Zapier and Make and nothing inside any CRM or sequencer.
- A business email or a direct phone number from Reverse Contact. Both are separate endpoints at 3 and 20 credits, charged only when one is found, and the email finder is asynchronous.
- Anything that repairs an email already sent. Personalisation renders at send time, so enrichment after the upload improves later steps and nothing before them.
- Campaign creation. Every upload is pointed at a campaign that already exists, built in Smartlead with its own sequence, mailboxes and schedule.

## Connect it, in this order

**Who has to do it:** Whoever can generate a Smartlead API key and whoever runs the server side of this, because the key cannot safely live in a browser. Plus a Reverse Contact key.
**How long:** An afternoon. Deciding to enrich before the upload rather than after it takes no time and saves all of it.

### 1. Decide to enrich before the upload, not after it

*Where:* Your own pipeline

Smartlead renders personalisation at send time, so a lead uploaded without the fields a sequence references gets the fallback text and nothing later repairs the email that went. Enriching first is also cheaper, because you can drop the rows that did not resolve instead of sending to them.

### 2. Put this on a server, because of where the key travels

*Where:* Not a browser, not a client app

Smartlead documents authentication as api_key in the query string rather than in a header. Request lines get logged by proxies, error trackers and anything that records a URL, so this route belongs server side and the key belongs on the ordinary rotation schedule rather than treated as a secret that stays secret.

### 3. Work out the hourly ceiling before the per-minute one

*Where:* Smartlead: your plan

Per API key the limits are 60 a minute and 1,000 an hour on Standard with a 10 a second burst, and 120 a minute and 3,000 an hour on Pro with a 20 a second burst. The hourly figure is what caps a bulk pass, and it is plan-wide across every endpoint combined rather than per endpoint.

### 4. 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 pass over a list spends 2 credits only where it needs to. Doing it in this order is what Reverse Contact recommends and it is the main lever on this bill.

### 5. Write the suppression rule before the enrichment rule

*Where:* Your pipeline

The response carries more reasons not to send than reasons to send. A current employer that disagrees with your record, an isInRemembrance flag, a confident null: each one is a row to drop rather than a row to personalise better.

### 6. Map the enriched values to the exact custom field names the sequence uses

*Where:* Smartlead: the campaign sequence

Custom fields are key-value pairs and the key has to match the merge variable in the sequence character for character. A near-miss renders the fallback, which looks like a sending problem and is a naming problem.

### 7. Upload in batches and leave the tight endpoints alone

*Where:* Smartlead: the add-leads endpoint

Three endpoints carry their own limit of 10 requests per 60 seconds per account, independent of the plan-wide figure: leads statistics by campaign, all-leads activities, and domain-wise mailbox health metrics. None of them belongs in a loop.

### 8. Send one lead to a test campaign and read the rendered email

*Where:* Smartlead: a campaign with one mailbox

The rendered first email is the only artefact that tells you whether the mapping worked. The API reporting success means the lead was accepted, which is a different claim entirely.

Two of those eight exist because of one documented detail, which is that the key rides in the URL. That decides where the code runs and how the key is handled, and it is the single biggest operational difference between this pair and [the lemlist one](pair:lemlist+reverse-contact), where the same key goes in a Basic auth header.

## How to check it worked

- Enrich one row, upload it to a test campaign with one mailbox, and read the rendered first email. That is the only place a mismatched custom field name is visible, and it is invisible everywhere else.
- Upload a row deliberately missing a field the sequence references. The fallback text should appear, and seeing what it looks like once is how you find out whether your fallbacks are good enough to send.
- Run 70 requests inside a minute on Standard and watch the limit bite at 60. Knowing the ceiling is real changes how a thousand-row pass gets scheduled.
- Grep your logs for api_key after the first run. If the key is in them, that is the finding, and it is better found on day one than during an audit.

## 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 email went out with the fallback text instead of the enriched value | Custom fields are key-value pairs and the key has to match the merge variable in the sequence exactly. A near-miss renders the fallback rather than failing. | Compare the field names character for character, then send one lead to a test campaign and read the rendered email. The rendered email is the only place this is visible. |
| The upload reported success and the lead is not in the campaign | Add lead to campaign requires a campaign that already exists and is active. Campaigns are built in Smartlead, not through this pipeline. | Confirm the campaign id against the account rather than against your own config. A campaign renamed or archived in Smartlead breaks the upload without the id changing. |
| 429 after about a thousand requests | The hourly ceiling is 1,000 on Standard and 3,000 on Pro, per API key and plan-wide across every endpoint combined, with per-minute limits of 60 and 120 underneath it. | Pace against the hourly figure rather than the per-minute one, and count every endpoint toward it. The per-minute limit is the one people test and the hourly one is the one that stops a bulk pass. |
| 429 from one specific endpoint while everything else works | Three endpoints carry their own limit of 10 requests per 60 seconds per account, independent of the plan-wide figure: leads statistics by campaign, all-leads activities, and domain-wise mailbox health metrics. | Take them out of the loop entirely and call them on a schedule instead. No plan raises these three, so there is no upgrade that fixes it. |
| The API key turned up in a log | Smartlead documents authentication as api_key in the query string, and request lines are logged by proxies, error trackers and anything that records a URL. | Run this server side, keep the key out of any client, and rotate it on a schedule rather than only after an incident. This is a property of the API rather than a mistake you made. |
| A campaign reached somebody who left the company | The enrichment wrote a title and nothing compared the returned current employer against the company on the row. | Compare currentPosition.companyName with your own value and drop the row rather than uploading it. On a sender this check is worth more than any personalisation it would have enabled. |
| Everything stopped, including the calls that were free | Below 2 Reverse Contact credits the free Check endpoints are paused too and answer 402 NO_CREDITS, because the fetch a check precedes can itself cost 2. | Branch on quotas.workspace.credits.left, which rides on every response. GET /v2/usage keeps answering whatever the balance, so a balance check never fails for the reason the lookup did. |
| Credits expired before a campaign used them | Reverse Contact credit packs run from 5K to 1M and are valid 3 months, and a sender that works in campaign bursts does not spend evenly. | Size the pack to a quarter of real volume rather than to a discount, or move to an Unlimited plan, where the cached endpoints the plan names stop being metered at all. |

## What breaks, from the vendors' own docs

- **The key is a query parameter, not a header.** Smartlead documents authentication as api_key in the query string. URLs get logged, by proxies, by error trackers, by anything that records a request line, so this route should run server side and the key should be rotated on the normal schedule rather than treated as a secret that stays secret.
- **1,000 requests an hour on Standard.** Per API key: 60 a minute and 1,000 an hour on Standard with a 10 a second burst, 120 a minute and 3,000 an hour on Pro with a 20 a second burst. The hourly ceiling is the one that bites on a bulk pass, and it is plan-wide across every endpoint rather than per endpoint.
- **A few endpoints carry their own limit.** Smartlead notes that some endpoints are expensive enough to have a dedicated limit independent of the plan-wide one. Check the endpoint you intend to hammer before designing a loop around the headline figure.
- **Personalisation renders at send time.** A lead uploaded without the fields a sequence references gets the fallback text, and nothing later repairs the email that already went. Enrichment belongs before the upload, which is also where it is cheapest, because you can drop the rows that did not resolve instead of sending to them.
- **Credit packs expire after 3 months.** Reverse Contact credit packs run 5K to 1M and are valid 3 months. A sender that runs in campaign bursts can reach the end of a quarter holding credits it paid for and cannot use, which is the case their Unlimited plans are priced for.

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

### Smartlead

- **Base:** `https://server.smartlead.ai/api/v1`
- **Auth:** API key as a query parameter.

| Call | Request | What it does |
|---|---|---|
| `POST /campaigns/{id}/leads` | `{ "lead_list": [ { "email": "...", "custom_fields": {...} } ] }` | Push the survivors of your suppression rules into a campaign. |

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

- Webhooks fire on every send, reply, bounce and unsubscribe. Route replies to a human within minutes; send the rest to a report.
- Entry pricing comes off a plan slider. Confirm the tier against your own mailbox count rather than budgeting from the headline.

Docs: https://api.smartlead.ai/reference

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

- Smartlead API: rate limits: https://api.smartlead.ai/guides/rate-limits
- Smartlead API: authentication and base URL: https://api.smartlead.ai/authentication
- Smartlead API: webhook integration guide: https://api.smartlead.ai/guides/webhook-integration
- 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-11, summarised on the page: https://www.reversecontact.com/integrations-hub/reverse-contact-integrations/smartlead-reverse-contact-integration#reddit
- This pair, with the reasoning behind each step: https://www.reversecontact.com/integrations-hub/reverse-contact-integrations/smartlead-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.*
