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

# Clay and Attio

> Generated from https://www.reversecontact.com/integrations-hub/clay-integrations/clay-attio-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:** Clay Growth or above, an Attio workspace, and an Attio workspace admin to authorise the connection

**What moves:** contacts, companies, custom objects, both ways.
**How it is built:** native. **Effort:** hours.

## The short version

The cleanest CRM pair on the Clay hub, because Attio has no fixed object model to fight: the Object dropdown is populated from your workspace, so a custom object is as reachable as People or Companies. Clay provides two import sources and four write actions, three of which cost a credit and one of which, the lookup, is free and is the one the vendor tells you to run first. The real constraints are not features. They are who is allowed to authorise the connection, a write budget on Attio's side that a single request can spend three times over, and the fact that none of this exists below Clay Growth.

## Which Clay plan reaches an Attio workspace

Rows: Clay plan. Columns: What you are trying to do. This is not a grid of Attio editions, because Attio does not gate the integration: the constraint on its side is a rate limit and an admin permission, neither of which you can buy your way past. The question is entirely which Clay plan includes CRM integrations, and the answer is the same one that governs every other CRM pair on this hub.

| Clay plan | Import Attio records | Write back to an object | Import beyond 250,000 |
|---|---|---|---|
| Free | Not included | Not included | Not included |
| Launch | Not included | Not included | Not included |
| Growth | Included | Included | Not included |
| Enterprise | Included | Included | Included |

- **Included.** Clay's plan comparison marks CRM integrations as included on Growth and on Enterprise, and the row links to the list of CRMs available through integrations.
- **Not included.** Not available on that plan at any volume. The third column is the Audiences row rather than a feature flag: Growth is capped at 250,000 imports from a CRM or data warehouse, and only Enterprise is unlimited.

Counted off that grid, of twelve pairings: five give you included, seven give you not included.

The first two rows read identically again, which is the same sentence this hub keeps having to write: the entry paid plan buys nothing for a CRM pair, so the only upgrade that changes anything is the one to Growth. The Enterprise column differs on volume alone, which is the right shape for a gate: it is a ceiling you can measure against your own record count rather than a feature you are missing.

## 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 |
|---|---|---|
| Attio records | One way, in | Import records pulls from any object, narrowed by a saved View or a JSON filter query, sorted, and capped by a Limit whose maximum is 50,000 records. |
| An Attio list | One way, in | Import records from list is the second source, taking a list rather than an object, with the same filter, sort and 50,000 limit. |
| New records | One way, out | Create record writes into any object and costs 1 credit per run. It does not check for an existing match, which is what makes Upsert the safer default. |
| Updated records | One way, out | Update record needs the Attio Record ID, costs 1 credit, and carries a Multiselect Behavior switch that decides whether multiselect values are appended or overwritten. |
| Matched records | One way, out | Upsert record matches on a unique attribute you choose from the writable unique attributes on that object, then updates or creates. 1 credit, and the action to reach for when you are not certain. |
| A lookup | One way, out | Lookup records is free and returns up to 10 matching records. It is a read performed from Clay, so it counts as a call out even though nothing changes in Attio. |

## Which field lands where

There is no fixed field map, because there is no fixed object model. Clay populates the Object dropdown and the Object Schema from your connected workspace, so what you can write is whatever your Attio workspace holds on the day you build it. What is fixed is which action takes which identifier, and that is the part worth reading twice.

| In Clay | In Attio | What to know about the match |
|---|---|---|
| Import records | Rows in a Clay table | Takes an Object, an optional View, an optional JSON Filter ignored when a View is set, a Sort and a Limit of up to 50,000. |
| Import records from list | Rows in a Clay table | Takes an Attio list rather than an object, with the same filter, sort and 50,000 limit. |
| Create record | A new record in an Attio object | Object plus Object Schema attributes. 1 credit per run. Performs no match, so it will happily create a second copy. |
| Lookup records | Up to 10 matching records | Free. Takes a Record ID or Object Schema filters, and optional JSON path filters to trim the response. Required before a create if you care about duplicates. |
| Update record | An existing record, by Record ID | 1 credit. Requires the Attio Record ID, so it follows a lookup or an import. Multiselect Behavior appends or overwrites multiselect values. |
| Upsert record | A matched or new record | 1 credit. Matches on a writable unique attribute such as email or domain, then updates or creates. The safe default when you are unsure. |

**What does not cross:**

- Anything Attio does not expose as a writable attribute. The Object Schema is populated from your workspace, so if it is not an attribute there it is not a field here.
- Deletion. None of the four actions removes a record, so a row that should no longer exist in Attio has to be handled in Attio.
- More than ten lookup results. The lookup is a check rather than a query, and reconciling a large set means importing it and comparing in the table.

## Connect it, in this order

**Who has to do it:** A Clay builder, plus an Attio workspace admin. The admin is not optional: Clay documents that only workspace admins can authorise the connection.
**How long:** An hour, most of it deciding the matching attribute rather than connecting anything.

### 1. Confirm the Clay plan

*Where:* Clay: pricing

CRM integrations read not included on Free and not included on Launch in Clay's plan comparison, and included from Growth. Attio counts as a CRM here. Check this first, because both the import sources and the write actions are behind the same gate and there is no half-build to start on a cheaper plan.

### 2. Get an Attio admin to authorise the connection

*Where:* Clay: a workbook

In a workbook click Add, search for Attio, and you will be asked to Select Attio account. Adding an account runs an OAuth flow that only an Attio workspace admin can complete. Line this up before you start: it is the step most likely to stall a build for a day.

### 3. Choose the source, and choose View or Filter but not both

*Where:* Clay: Import records

Import records takes an Object, with an optional saved View, an optional JSON Filter, a Sort and a Limit of up to 50,000. A View takes precedence and the Filter is then ignored, so pick one deliberately. If you set neither, every record in the object is returned up to the limit.

### 4. Decide the matching attribute before any write

*Where:* Attio: the object's attributes

Upsert record matches on a unique attribute chosen from the writable unique attributes on that object, typically an email address or a domain. This is the single decision that determines whether this integration creates duplicates for the next year, so make it explicitly rather than accepting the first option in the dropdown.

### 5. Look up before you create

*Where:* Clay: Lookup records

The vendor's own best-practice note says to run the free Lookup records action first to check for duplicates before creating new records. It returns up to 10 matches. Build the table so the write action only runs when the lookup came back empty.

### 6. Add a conditional run, then turn on auto-update

*Where:* Clay: run settings

Only run if gates the enrichment on conditions you set, and Auto-update syncs new rows back to Attio as they arrive. Add the condition before the auto-update, or the first unattended run writes every row including the ones the enrichment failed on.

Nothing is installed in Attio, so removing this means deleting the connection in Clay. What does persist is whatever you wrote, which is why the matching attribute and the conditional run are the two steps worth slowing down for.

## How to check it worked

- Run Lookup records on a person you know exists and confirm it returns them. It is free, so this is the cheapest possible proof that the connection and the object selection are both right.
- Upsert the same record twice and confirm Attio still holds one. If you get two, the matching attribute is not unique in the way you assumed, and every write after this point will have the same problem.
- Update a multiselect attribute and check whether the existing values survived. Multiselect Behavior decides between appending and overwriting, and the wrong setting removes data silently rather than failing.
- Import with a Filter while a View is selected, and confirm you get the View's rows rather than the Filter's. Seeing the precedence once is the only reliable way to remember it.

## 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 OAuth flow will not complete and Attio is never connected | The person connecting is not an Attio workspace admin. Clay documents that only workspace admins can authorise this connection. | Have an Attio workspace admin run the Add account step. There is no delegated permission for this in Clay, so it has to be them in the browser rather than a scope you can be granted. |
| The filter on an import is doing nothing | A saved View is selected on the same source. Clay documents that the View takes precedence and the Filter is ignored when both are present. | Remove the View if you want the Filter to apply, or move the logic into the View. Nothing warns you about this, so check it first whenever an import returns the wrong rows. |
| The import returned the entire object | Neither a View nor a Filter was set. Clay documents that all records are returned when neither is provided. | Set one of them, and set the Limit as well. The Limit maximum is 50,000, which is also the point at which an import becomes a modelling problem rather than a configuration one. |
| Attio is filling up with duplicates | Create record is being used where Upsert record is wanted. Create performs no match and will write a second copy of a record that already exists. | Switch to Upsert record and choose the matching attribute deliberately, or run the free Lookup records first and make the create conditional on it returning nothing. Neither fixes duplicates already there. |
| Multiselect values disappeared after an update | Multiselect Behavior was set to overwrite rather than append, so the incoming values replaced the existing ones. | Set it to append on any attribute where Attio is the system of record for values Clay does not know about. This fails silently, so check one record after changing the setting rather than waiting for somebody to notice. |
| 429 Too Many Requests from Attio during a bulk write | The write budget is 25 requests a second, and a request that creates referenced records spends more than one: a person with two new companies attached counts as 3. | Read the Retry-After header rather than retrying immediately, and reduce the fan-out by creating referenced records first so later writes only reference existing ones. Identical references within one request are merged and counted once. |
| A backfill that worked before now hits limits | Attio states it may reduce the rate limit during incident response, and may permanently lower it for specific APIs that handle a lot of data. | Treat the ceiling as variable rather than fixed. Anything bulk should back off on a 429 and read the endpoint documentation for a lower published limit, rather than assuming last quarter's throughput. |

## What breaks, from the vendors' own docs

- **Only an Attio workspace admin can connect it.** Clay's documentation states plainly that only Attio workspace admins can authorise the OAuth connection. That makes the first step of this integration an access request rather than a configuration task, and it is the most common reason a Clay builder cannot finish the setup on their own. Find out who the admins are before you book time to build.
- **A lookup returns ten records and no more.** The Lookup records action returns up to 10 matching records. That is enough to check whether a person exists and not enough to reconcile a list, so a deduplication pass over thousands of rows is not a lookup, it is an import followed by a comparison in the table.
- **Attio allows 25 writes a second, and one request can cost three.** The published ceiling is 100 requests a second for reads and 25 a second for writes. The part that surprises people is that a single write can count as several: writing a record reference with target_record_reference set to create means every referenced record Attio creates counts as another write, so creating a person with two new companies attached spends 3 of the 25. Identical references in one request are merged and counted once.
- **An import stops at 50,000 records.** Both sources take an optional Limit and Clay documents the maximum as 50,000 records. Above that the import is not a single source, it is several, narrowed by view or by filter, which is a modelling decision rather than a setting you can raise.
- **A View silently beats a Filter.** If a source has both a saved View and a JSON Filter, Clay documents that the View takes precedence and the Filter is ignored. Nothing reports this. A table that returns the wrong rows after somebody adds a view is the shape of the bug, and the only tell is that your filter appears to do nothing.
- **Attio can lower the limit without you changing anything.** Attio states it may occasionally reduce the rate limit as part of incident response, and may permanently lower it for specific APIs that handle a lot of data, documented on the endpoint. So a backfill that worked last quarter is not a guarantee, and anything bulk should read the 429 and its Retry-After header rather than assume a fixed budget.

## 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: Attio integration: https://university.clay.com/docs/attio-integration
- Attio: handling rate limits: https://docs.attio.com/rest-api/guides/rate-limiting
- Attio: objects and lists: https://docs.attio.com/docs/objects-and-lists
- Clay pricing: https://www.clay.com/pricing
- 14 practitioner threads read on 2026-10-28, summarised on the page: https://www.reversecontact.com/integrations-hub/clay-integrations/clay-attio-integration#reddit
- This pair, with the reasoning behind each step: https://www.reversecontact.com/integrations-hub/clay-integrations/clay-attio-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.*
