---
name: lemlist-reverse-contact-integration
description: Connect lemlist 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 lemlist and Reverse Contact together, or asks why data is not moving between them.
---

# lemlist and Reverse Contact

> Generated from https://www.reversecontact.com/integrations-hub/lemlist-integrations/lemlist-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 lemlist API key, sent as HTTP Basic

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

## The short version

lemlist is the easiest of the sequencers to connect and the most interesting to reason about, because it sells enrichment itself. The connection is a few lines once you get past the Basic auth with its leading colon, and the limits are comfortable at 20 requests per 2 seconds. The real question is not how to add a second provider but how to order two, which is a waterfall question and the only honest answer involves running both over 500 of your own rows and counting.

## What each ordering costs on the rows that overlap

Rows: How you arrange the two. Columns: What you pay on a row that is. lemlist sells enrichment and so does Reverse Contact, so the real decision on this pair is sequencing rather than connection. The grid walks the four kinds of row a list contains and asks what each arrangement pays for them. Only the conditional orderings pay once per row.

| How you arrange the two | Resolved by both providers | Resolved only by lemlist | Resolved only by Reverse Contact | Resolved by neither |
|---|---|---|---|---|
| Both, unconditionally | Two lookups | Two lookups | Two lookups | Two lookups |
| lemlist first, Reverse Contact on the nulls | One lookup | One lookup | Two lookups | Two lookups |
| Reverse Contact first, lemlist on the nulls | One lookup | Two lookups | One lookup | Two lookups |
| Reverse Contact only | One lookup | One lookup and an empty row | One lookup | One lookup |

- **One lookup.** Paid once. Either the first provider resolved the row and the second never ran, or only one provider was ever going to try. This is what a conditional ordering buys you.
- **Two lookups.** Paid twice for one filled field, or twice for nothing. Running both unconditionally does this on every row in the list, which is the top line of the grid and the arrangement most teams start with.
- **One lookup and an empty row.** Paid once and the row is still empty, because the provider that could have resolved it was never asked. The cost of dropping a source is coverage rather than money.

Counted off that grid, of sixteen pairings: seven give you one lookup, eight give you two lookups, one gives you one lookup and an empty row.

The bottom two rows are the honest shortlist and the difference between them is a measurement rather than an argument: run both over 500 of your own rows and count how many each resolves alone. One detail tips it when the counts are close, which is that a Reverse Contact miss costs nothing at all, because every 4xx and 5xx is free, so putting it second is cheaper than putting a metered provider there.

## What actually syncs

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

| What | Direction | What that means in practice |
|---|---|---|
| The list, before the campaign | One way, out | Enrich each lead from its email with /v2/enrich/persons. 2 credits on a match. |
| Lead creation | One way, in | POST the lead to the campaign with the enriched values as custom variables. |
| Activity webhooks | One way, out | lemlist fires events on opens, replies and other activity, which is how a reply reaches a CRM. |
| Anything back to Reverse Contact | One way, out | Nothing. This is a read layer, and your pipeline decides which lemlist variables are written. |

## Which field lands where

The mapping here is simple and the interesting column is cost, because lemlist sells enrichment too. Every row below can in principle be filled by either provider, which makes the order they run in the only decision that changes the bill.

| In lemlist | In Reverse Contact | What to know about the match |
|---|---|---|
| An email on the lead | POST /v2/enrich/persons, 2 credits | Identity, the current role, history, education, skills and location on one schema. A confident null costs nothing, because every 4xx and 5xx is free, which is what makes it safe to put second in a waterfall. |
| 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. |
| A profile URL already on the lead | POST /v2/fetch/persons, 1 credit | Half the credits, and unmetered from the $249 plan rather than the $699 one. A multichannel sender often already holds one, because the channel needs it. |
| The free freshness check | POST /v2/fetch/persons/check, 0 credits | Whether a profile is cached and when it was last updated. The cheapest possible tiebreak between two providers on a per-row basis. |
| currentPosition.title and company.name | lemlist custom variables | The two values most openers reference. A missing variable renders the fallback text rather than stopping the send, which is why the resolved rate has to be counted rather than inferred. |
| The lemlist API key | HTTP Basic, with a leading colon | Username always empty, password the key, and the encoded string starts with a colon. Not Bearer, and the error for getting it wrong reads like a bad credential. |
| Its own enrichment, including a bulk endpoint | The other provider in the waterfall | This is the fact that shapes the page. Two sources that overlap need an order rather than a toggle: cheapest high-coverage first, the second only on what came back null. |
| 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 a send rather than improve one

The rest of this directory treats an enrichment response as values to write. On a multichannel sender it is also a list of reasons not to contact somebody at all, and a wrong row here is an email and a connection request rather than only an email.

| 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 lemlist. There is none, which is consistent with Reverse Contact maintaining apps on Clay, Zapier and Make and nothing inside any CRM or sequencer.
- A machine-readable rate limit reset. X-RateLimit-Reset is a human-readable date string by design, and Retry-After is the integer to use instead.
- 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.
- Anything that repairs an email already sent. A fallback renders at send time, so an unenriched row is a sent email with generic text in it rather than an error anywhere.

## Connect it, in this order

**Who has to do it:** Whoever can generate a lemlist API key from Settings, plus whoever can create a Reverse Contact key. No admin on either side.
**How long:** An afternoon to connect. Deciding the order of the two enrichment providers is the part that takes a week of measurement.

### 1. Decide the order of the two providers before you connect either

*Where:* A spreadsheet, not a settings screen

lemlist sells enrichment itself, so this is not a question of adding a provider but of ordering two. Running both unconditionally means paying twice on every row they can both resolve. The only honest way to settle it is to run both over 500 of your own rows and count, and that measurement is the irreversible-feeling decision on this page.

### 2. Enrich before the lead enters a campaign

*Where:* Your own pipeline

A missing variable renders the fallback text rather than stopping the send, which is the behaviour you want and the reason an unenriched row is easy to miss. Nothing later repairs the email that has gone, so the ordering is the design.

### 3. Get the Basic auth right, including the leading colon

*Where:* lemlist: Settings, Integrations, Generate a new API key

lemlist uses HTTP Basic rather than Bearer. The username is always empty, the password is the key, and the string you encode is a colon followed by the key. Their documentation shouts about this because people get it wrong, and a Bearer header returns an auth error that looks exactly like a bad key.

### 4. Store the key on the way out of the dialog

*Where:* lemlist: the key generation screen

lemlist states that you will not be able to see the key again. That is one sentence and it costs a regeneration and every integration using the old key if you skip it.

### 5. Parse X-RateLimit-Reset as a date, not a number

*Where:* Any lemlist API response

The limit is 20 requests per 2 seconds on all routes, metered per API key. Retry-After is an integer count of seconds, and X-RateLimit-Reset is a human-readable date string, which lemlist calls out specifically. Code that assumes an integer either crashes or parses it to zero and retries immediately.

### 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 how fresh it is, which also happens to be the cheapest way to decide between two providers on a per-row basis rather than a per-list one.

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

*Where:* Your pipeline

A current employer that disagrees with your record, an isInRemembrance flag, a confident null: each is a row to drop. On a sender that runs multichannel, a wrong row is an email and a connection request rather than just an email.

### 8. Measure the resolved rate on the list, not the reply rate

*Where:* Your own data

Because a fallback renders rather than failing, a campaign with a third of its rows unenriched looks exactly like a campaign that is working. Count how many rows carry the field before you send, and the reply rate stops being the thing that tells you.

The first and last steps are both about measurement rather than configuration, which is unusual in this set and is the consequence of the other vendor selling the same thing you are adding. [Smartlead sells no enrichment](pair:smartlead+reverse-contact) of its own, and the same build there is a straight line.

## How to check it worked

- Send a request with a Bearer header on purpose and read the error. It looks like a bad key rather than a bad scheme, which is exactly why the colon is worth proving once.
- Run both enrichment providers over the same 500 rows and count four numbers: resolved by both, by lemlist only, by Reverse Contact only, by neither. Those four numbers settle the ordering question and nothing else does.
- Read X-RateLimit-Reset from a live response and try to parse it with whatever your code uses for timestamps. If it returns zero, you have found the bug before it found you.
- Upload a row deliberately missing a variable the campaign references and read the rendered email. The fallback renders silently, so this is the only way to see what an unenriched row actually sends.

## 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 |
|---|---|---|
| An authentication error that looks like a bad key | lemlist uses HTTP Basic rather than Bearer. The username is always empty, the password is the key, and the encoded string must start with a colon. | Encode a colon followed by the key. lemlist shouts about this in its own documentation because it is the most common mistake on the API, and the error message does not point at it. |
| The retry loop fired immediately and made things worse | X-RateLimit-Reset is a human-readable date string rather than a Unix timestamp, so code that parses it as an integer gets zero and retries at once. | Use Retry-After, which is an integer count of seconds. lemlist calls the date format out specifically, which is a fair warning that it has caught people. |
| 429 from a parallel worker | The limit is 20 requests per 2 seconds, applied to all routes and metered per API key rather than pooled across a team. | Serialise or pace at about ten a second. At that rate a thousand rows takes under two minutes, so there is rarely a reason to parallelise this at all. |
| The key is gone and nobody wrote it down | lemlist states that you will not be able to see the key again after generating it. | Generate a new one, and expect every integration holding the old key to stop at the same moment. Worth knowing which those are before you click. |
| A third of the campaign went out with fallback text | A missing variable renders the fallback rather than stopping the send, which is the behaviour you want and makes an unenriched row invisible. | Count the resolved rate on the list before sending rather than waiting for the reply rate to tell you. A campaign with a third of its rows unenriched looks exactly like one that is working. |
| The enrichment bill is double what the filled fields suggest | Two overlapping providers running unconditionally both charge for every row they can resolve, and most rows resolve on both. | Make the second one conditional on the first returning null. A Reverse Contact miss costs nothing, which makes it the cheaper of the two to put second. |
| A connection request reached somebody who changed job | Nothing compared the returned current employer against the company on the row, and a multichannel campaign acts on more than one channel per row. | Compare currentPosition.companyName with your own value and drop the row. The cost of a wrong row is higher here than on an email-only sender because it is wrong in two places. |
| 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 same reason the lookup did. |

## What breaks, from the vendors' own docs

- **Basic auth, with a colon in front of the key.** lemlist uses HTTP Basic rather than Bearer. The username is empty, the password is the key, and the string to encode is :YourApiKey with the leading colon. Their documentation shouts about it because people get it wrong, and a Bearer header returns an auth error that looks like a bad key.
- **20 requests per 2 seconds, per key.** The limit applies to all routes and is metered per API key. At that rate a thousand-row list takes under two minutes, so this is rarely the constraint, but a parallel worker will find it quickly.
- **The reset header is a human-readable date.** X-RateLimit-Reset comes back as a formatted date string rather than a Unix timestamp, which lemlist calls out specifically. Code that assumes an integer will either crash or, worse, parse to zero and retry immediately.
- **Two enrichment sources need an order, not a toggle.** lemlist ships its own enrichment, including a bulk endpoint. Running two providers without deciding which goes first means paying twice on the rows both can resolve. Cheapest high-coverage source first, the second only on what came back null.
- **A fallback is not a blank.** A missing variable renders the fallback text rather than stopping the send, which is the behaviour you want and the reason an unenriched row is easy to miss. Check the resolved rate on the list rather than waiting for a reply rate to tell you.

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

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

- lemlist API: authentication: https://developer.lemlist.com/api-reference/getting-started/authentication
- lemlist API: rate limits: https://developer.lemlist.com/api-reference/getting-started/rate-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-11, summarised on the page: https://www.reversecontact.com/integrations-hub/lemlist-integrations/lemlist-reverse-contact-integration#reddit
- This pair, with the reasoning behind each step: https://www.reversecontact.com/integrations-hub/lemlist-integrations/lemlist-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.*
