---
name: clay-lemlist-integration
description: Connect Clay and lemlist: what syncs, which editions carry it, the setup order, and the failures to expect. Covers contacts, lists. Use when the user wants to set up, audit or troubleshoot Clay and lemlist together, or asks why data is not moving between them.
---

# Clay and lemlist

> Generated from https://www.reversecontact.com/integrations-hub/clay-integrations/clay-lemlist-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:** Clay Launch or above, a lemlist API key, and a campaign that already exists

**What moves:** contacts, lists, one way, out of Clay.
**How it is built:** native, built on the api. **Effort:** minutes.

## The short version

A small, well-scoped integration that does the one thing a CSV cannot: it carries the thinking with the lead. Three actions, add, update and look up, each keyed on a campaign that already exists in lemlist, with the personalisation written in a Clay column delivered as part of the push. The conditional run setting is the part worth using properly, because it turns the table into the thing that decides who is worth a campaign slot rather than a list that fills one. What it is not is a sync: nothing comes back, so engagement lives in lemlist.

## Which Clay plan reaches which kind of tool

Rows: Clay plan. Columns: What you are connecting. Clay sorts integrations into plan bands rather than pricing them one by one, and the order catches people out: a data provider costs nothing extra, a sequencer starts one tier up, and a CRM starts two.

| Clay plan | Data providers, like Apollo | Sequencers: lemlist, Smartlead, Outreach | CRMs: HubSpot, Salesforce |
|---|---|---|---|
| Free | Included | Not included | Not included |
| Launch | Included | Included | Not included |
| Growth | Included | Included | Included |
| Enterprise | Included | Included | Included |

- **Included.** Each band is stated on Clay's own integration catalogue: Apollo is Included in All Plans, lemlist, Smartlead and Outreach are all Included in Launch+, and the pricing page marks CRM integrations as included from Growth.
- **Not included.** Not available on that plan at any volume. Every action on all four is also marked Bring Your Own Account Required, so a subscription with the other vendor is a separate prerequisite from the Clay plan.

Counted off that grid, of twelve pairings: nine give you included, three give you not included.

lemlist sits in the middle column, so the Clay gate is the mild one and Launch covers it. The number more likely to shape this pair is on lemlist's side: 20 requests per 2 seconds per API key, which is the ceiling a bulk push runs into long before any plan does.

## What actually syncs

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

| What | Direction | What that means in practice |
|---|---|---|
| New leads | One way, out | Add lead to campaign, taking a campaign id plus email, LinkedIn URL, name, phone number and the rest of your mapped fields. |
| Existing leads | One way, out | Update lead in campaign, keyed on the email address or the lead id, across the same field set. |
| Duplicate checks | One way, in | Look up lead in campaign by email, which is how a table avoids adding somebody who is already being sequenced. |
| Personalised copy | One way, out | Per-lead data including the email copy written in a Clay column, so the personalisation is part of the lead rather than a later edit. |
| Campaigns themselves | Events only | Not created from Clay. The campaign, its steps, its schedule and its sending identities are all set up in lemlist first. |
| Replies, opens and bookings | Events only | Nothing returns to the table. lemlist is where performance lives, and its [HubSpot integration](pair:hubspot+lemlist) is how that reaches a CRM. |

## Which field lands where

Clay exposes three actions. What they do once the request reaches lemlist is documented on lemlist's side rather than Clay's, and two of those behaviours decide how you build the table.

| In Clay | In lemlist | What to know about the match |
|---|---|---|
| Add Lead to Campaign | Campaign ID required, the rest optional | Email, LinkedIn URL, name, phone and more. lemlist documents the underlying endpoint as creating and never updating, so this is not an upsert however it is used. |
| Update Lead in Campaign | Campaign ID, plus email or lead ID | The action for changing an existing lead. Pairing it with the lookup is what turns the two into the upsert that the add action is not. |
| Lookup Lead in Campaign | Email address or lead ID | Checks whether the lead exists in a campaign. The cheapest column on the table and the one that makes the other two safe. |
| Company fields | The shared company record | companyName, companyDomain, companyIndustry and any company-prefixed key reach the company the lead is matched to, which every other lead linked to it reads. Not scoped to the lead. |
| Any other key you send | A custom variable on the lead | Usable in the campaign as a merge tag. Letters, digits, underscore, hyphen, space and hash are kept; every other character becomes an underscore, and values are stored as text. |
| The API key | HTTP Basic, empty username | lemlist uses Basic rather than Bearer, with the key as the password and a leading colon before it. Clay handles the encoding; what it means for you is that the key is a credential, not a token with scopes. |
| Campaign creation | Not an action | The campaign has to exist in lemlist first. lemlist's own API can create one, but Clay does not expose that. |
| Replies, opens, meetings | Nothing comes back | There is no read action for engagement, so performance lives in lemlist and the table is a feed. |

### What lemlist does with a lead you add twice

| The action | How it reads on the record |
|---|---|
| The contact already has a lead in this campaign | 400 LEAD_ALREADY_IN_CAMPAIGN, and nothing is written |
| The contact has a lead in a different campaign, with deduplicate on | 409 LEAD_ALREADY_IN_OTHER_CAMPAIGN |
| The campaign's own remove duplicates setting | Does not drive that check. Only the deduplicate parameter does |
| The contact and company behind the lead | Updated with the fields you sent, even though the lead was refused |
| updateStrategy left at its default | overwrite: sent values replace stored ones, and an empty value clears the stored one |
| updateStrategy set to fillEmptyOnly | Only empty fields are filled, and kept values are listed back as FIELDS_KEPT warnings |

**What does not cross:**

- An upsert. The add endpoint creates and never updates, so a lead that already exists is an error rather than a refresh, and the Update action is a separate column.
- Company data scoped to one lead. lemlist documents company-prefixed fields as reaching the shared company record, with a separate Upsert Company endpoint for editing one on purpose.
- Any character outside letters, digits, underscore, hyphen, space and hash in a custom variable name. They are replaced, silently, before storage.

## Connect it, in this order

**Who has to do it:** Whoever owns the Clay workbook, plus somebody who can generate a lemlist API key. The key is shown once and never again.
**How long:** Ten minutes, assuming the lemlist campaign already exists.

### 1. Check the Clay plan band

*Where:* Clay: pricing

Clay's catalogue puts lemlist at Included in Launch+, so a Free workspace cannot run it. Every action is also marked Bring Your Own Account Required, which here means your own lemlist subscription.

### 2. Create the campaign in lemlist first

*Where:* lemlist: Campaigns

Clay states the requirement directly: you must already have a campaign set up in lemlist to use this integration. All three actions take a Campaign ID, and there is no create-campaign action.

### 3. Generate the API key and store it immediately

*Where:* lemlist: Settings, Integrations

Profile picture, Settings, the Integrations tab, Generate a new API key. lemlist warns that you will not be able to see it again, so it goes into Clay or a password manager in the same minute it is created.

### 4. Connect the account from the enrichment panel

*Where:* Clay: Add enrichment, lemlist

Search lemlist, pick an action under Integrations, then + Add account and paste the key. Note what this key is: lemlist authenticates with HTTP Basic using an empty username and the key as the password, so it is a password in the literal sense.

### 5. Look up before you add

*Where:* Clay: Lookup Lead in Campaign

It checks whether a lead exists in a campaign by email or lead ID. The add action creates and never updates, so without this column the table has no way to tell a new lead from one it is about to be refused for.

### 6. Decide what the company fields are allowed to touch

*Where:* Clay: the mapped columns

Company name, company domain, company industry and any company-prefixed key reach the shared company record the lead is matched to, not that lead alone. Every other lead linked to the same company reads what you wrote.

### 7. Name custom variables the way lemlist will keep them

*Where:* Clay: additional fields

Any extra key-value pair you send is stored as a custom variable usable in the campaign as a merge tag. Only letters, digits, underscore, hyphen, space and hash survive; anything else, a full stop or a dollar sign, is replaced with an underscore.

### 8. Put the condition on the add column

*Where:* Clay: run settings, Only run if

All three actions take Auto-update and Only run if. The add is the one that cannot be undone from the table, so that is the column the score belongs on.

Three actions is the smallest sequencer integration on the Clay hub, and the brevity hides two behaviours that are not small: an add that refuses rather than updates, and company fields that write to a record shared across leads. Both are in lemlist's API documentation rather than in Clay's, which is why this page cites both.

## How to check it worked

- Add one lead, then add the same lead again. The second attempt should be refused rather than updating anything, which is the documented behaviour and worth seeing once.
- Add a lead whose company already exists in lemlist with a company field deliberately wrong. Then open another lead at that company and check what it now reads.
- Send a custom variable with a full stop in its name and look at what lemlist stored. The character is replaced with an underscore, so the merge tag in your campaign has to match the stored name.
- Check the rate headers if you are pushing in bulk. lemlist allows 20 requests per 2 seconds per API key and returns Retry-After, X-RateLimit-Limit, X-RateLimit-Remaining and X-RateLimit-Reset on every response.

## 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 |
|---|---|---|
| 400 LEAD_ALREADY_IN_CAMPAIGN | The contact already has a lead in that campaign. lemlist documents the add endpoint as one that creates and never updates, so this is the designed response rather than a fault. | Use the Update Lead in Campaign action for anybody already there, gated on a lookup column. Nothing was written by the refused call. |
| 409 LEAD_ALREADY_IN_OTHER_CAMPAIGN | Deduplication is on and the contact has a lead in a different campaign. | Decide whether somebody in another campaign should be enrolled again. Note that only the deduplicate parameter drives this check: the campaign's own remove duplicates setting does not. |
| A lead was refused and its details changed anyway | The lead is always new, and the contact and company it matches are updated with whatever fields you sent regardless. | Treat the add action as a write to the contact even when it fails as a lead. If that is not what you want, look up first and branch. |
| A populated field came back empty after a push | updateStrategy defaults to overwrite, where a sent value replaces the stored one and an empty value clears it. | Send overwriteIgnoreEmpty to keep stored values where your column is blank, or fillEmptyOnly to fill only what is empty. Kept values are reported back as FIELDS_KEPT warnings. |
| A merge tag is not resolving in the campaign | The custom variable name was rewritten on storage. Only letters, digits, underscore, hyphen, space and hash are kept, and anything else becomes an underscore. | Name the Clay column with characters lemlist keeps, and match the merge tag to the stored name rather than the one you typed. |
| A company field you wrote shows up on other people's leads | Company-prefixed fields reach the company record the lead is matched to, which is shared by every lead linked to it. | Keep company columns out of a bulk push unless you intend to edit the company. lemlist has a separate Upsert Company endpoint for doing it deliberately. |
| Requests started failing during a bulk run | lemlist rate-limits all routes at 20 requests per 2 seconds, per API key. | Read Retry-After and X-RateLimit-Remaining, which come back on every response. Note X-RateLimit-Reset is a human-readable date rather than a timestamp, which trips up anything parsing it. |
| Nobody can find the API key | lemlist shows it once at creation and never again. | Generate a new one in Settings, Integrations, and store it properly this time. Rotating it means re-entering it in Clay, since the connection is the key. |

## What breaks, from the vendors' own docs

- **An API key, not OAuth.** The connection is a lemlist API key pasted into Clay, taken from lemlist's settings. That means a long-lived credential sitting in another product, revocable only from lemlist, and rotating it breaks every table using it at once. It is the normal arrangement for this class of tool and it is worth knowing which tables hold it.
- **The campaign has to exist first.** Every action takes a campaign id and Clay cannot create a campaign. So the sequence design, the sending mailboxes and the schedule are lemlist decisions made before the table runs, and a table pointed at a campaign that was paused or deleted fails per row rather than announcing itself.
- **Nothing comes back.** There is no reply, open or booking data returning to Clay, so the table cannot suppress on engagement and cannot report on what the list produced. Teams that want that loop close it through the CRM both tools write to rather than between these two directly.
- **Credits are spent before the push.** The action itself is cheap; the waterfall that filled the row is not. Clay's conditional run setting is the control that matters, because it stops the expensive enrichment running on rows that were never going to qualify. Set the condition before the volume, not after the first bill.

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

### Clay

- **Base:** `Configured in the table, not through an API`
- **Auth:** Per-integration, set in the workbook.

| Call | Request | What it does |
|---|---|---|
| `ACTION HubSpot / Salesforce Lookup` | - | Read-only. Pulls records into the table and changes nothing in the CRM. |
| `COLUMN HTTP API` | `POST https://api.reversecontact.com/v2/enrich/persons\nHeaders: { "Authorization": "Bearer rc_...", "Content-Type": "application/json" }\nBody: { "email": "/Work Email" }` | `/Work Email` is a column reference, so each row posts its own value. This is how a provider with no native listing becomes a column. |
| `ACTION HubSpot / Salesforce Update` | - | Writes back. Immediately live to every CRM user. Turn on "ignore blank values" and exclude rep-owned properties. |

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

- **Clay bills per action on the attempt, not the result.** Effective cost per filled field is the action rate divided by your match rate. Order a waterfall cheapest-first and use conditional runs so the expensive source only sees the residue.
- Import a filtered slice, never the whole portal. Filter on the gap you are filling.
- Run read-only until the columns look right, write to ten rows, open them in the CRM, and only then schedule.

Docs: https://university.clay.com/docs/hubspot-integration-overview

## Filling the record this integration moves

The integration above moves a record between two systems. Neither of them creates what is in it, so a sync that works perfectly still carries whatever gaps the record arrived with. Reverse Contact resolves an email, a domain or a profile URL into a verified people and company record through one API, and returns null with a confidence score rather than a guess.

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

- Clay docs: lemlist integration: https://university.clay.com/docs/lemlist-integration-overview
- Clay integrations: lemlist: https://www.clay.com/integrations/data-provider/lemlist
- lemlist API: create lead in campaign: https://developer.lemlist.com/api-reference/endpoints/leads/create-lead-in-campaign
- 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
- 14 practitioner threads read on 2026-10-11, summarised on the page: https://www.reversecontact.com/integrations-hub/clay-integrations/clay-lemlist-integration#reddit
- This pair, with the reasoning behind each step: https://www.reversecontact.com/integrations-hub/clay-integrations/clay-lemlist-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.*
