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

# Attio and Reverse Contact

> Generated from https://www.reversecontact.com/integrations-hub/attio-integrations/attio-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:** An Attio workspace on a plan with automations, and a Reverse Contact API key

**What moves:** contacts, companies, custom objects, one way, into Attio.
**How it is built:** built on the api. **Effort:** hours.

## The short version

Attio is the only CRM in this directory that can run the whole enrichment inside its own automation builder: call the API, read the response, parse it, write the fields. No middle layer, no second meter and no engineer, which is a genuinely different answer from every other CRM here. The constraints are small and real: a 20-second block timeout that rules out live resolution, a Parse JSON step that fails on a type mismatch rather than degrading, and blocks that Attio currently labels legacy while it reworks the builder.

## Which CRM can run the whole enrichment in its own builder

Rows: The CRM. Columns: What it can do unaided. This is the table that decides a day of work and no vendor publishes it. All six CRMs in this directory have an automation builder, and what separates them is not whether they can send a request. It is whether they can read the answer, which is the entire job of an enrichment.

| The CRM | Call an outside API from its own automation | Read the response in a later step | Without writing any code | Without a particular edition or extra hub |
|---|---|---|---|---|
| Attio | Yes | Yes | Yes | Nearly |
| HubSpot, with Data Hub | Yes | Yes | No | No |
| HubSpot, without Data Hub | No | No | No | No |
| Salesforce | Yes | Yes | Nearly | No |
| Pipedrive | Yes | No | Yes | No |
| Zoho CRM, Enterprise and above | Yes | Yes | No | No |
| monday CRM | No | No | No | No |

- **Yes.** Documented on that CRM. Attio's Send HTTP request block provides the response status code and body as variable inputs for subsequent blocks, which is precisely what the second column tests, and Parse JSON turns that body into named fields.
- **Nearly.** Attio has a free plan and puts automations on the paid ones, so this route needs a paid workspace rather than a particular edition. On Salesforce an admin can do it through External Services and a Flow HTTP Callout without writing Apex, which is no code in the sense that matters and still a day of configuration.
- **No.** Not available. HubSpot puts both the webhook and the custom code action in Data Hub; a Pipedrive automation can fire a webhook and the documented action has only a webhook, a method and a body, with no response to read; Zoho needs Deluge and an Enterprise edition; and monday has no HTTP step in its automations at all.

Counted off that grid, of 28 pairings: eleven give you yes, two give you nearly, fifteen give you no.

One row is clean across the first three columns without a code editor or a separate hub, which is why this page has the shape it does. The row worth reading against it is Pipedrive, which looks identical on any feature list: both are mid-market CRMs with an automation builder and a webhook action, and the Pipedrive build is a webhook out, a worker somewhere else and a write back in, because the answer has nowhere to land.

## What actually syncs

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

| What | Direction | What that means in practice |
|---|---|---|
| Trigger | One way, in | A record created or updated in Attio, or an inbound Webhook received block. |
| The call | One way, out | Send HTTP request: POST to /v2/enrich/persons with an Authorization header and the record's email in the body. 2 credits. |
| The response | One way, in | Status code and body come back as variables. Parse JSON turns the body into named fields for the next block. |
| Write-back | One way, in | A record update block writes the parsed fields onto your own objects and attributes, custom ones included. |

## Which field lands where

Everything here happens in three blocks: Send HTTP request makes the call, Parse JSON turns the body into named fields, and a record update writes them onto your own objects. The fussy part is the middle one, because each field declares both a path and an output type.

| In Attio | In Reverse Contact | What to know about the match |
|---|---|---|
| Send HTTP request, POST | https://api.reversecontact.com/v2/enrich/persons | Supports DELETE, GET, HEAD, PATCH, POST and PUT, with the URL, headers, Content-Type and body all built from hard-coded text or variables from earlier blocks. The block provides the response status code and body as variables for everything downstream, which is the property this whole page rests on. |
| An Authorization header | Bearer rc_your_api_key | Custom headers are supported. Attio states that forbidden header names are not, and that it may block others as needed for platform security, so test this one before assuming it. |
| Parse JSON, Path | data.currentPosition.title | Written in the same syntax you would use to traverse the object in JavaScript: a root key on its own, a nested value as dot-joined keys, an array element by index in brackets. |
| Parse JSON, Output Type | String, Number or Boolean | Three types, and Attio states the type must match what the path evaluates to or the block fails. String and String (Array) map to Text, Email Address, Domain, Select, Multi-Select, Currency, Status and Phone; Number and Number (Array) to Number and Rating; Boolean to Checkbox. |
| A Condition block on the status code | 200, 402 or 429 | The three outcomes worth branching on. A 402 means the credit balance reached zero, which pauses even the free check endpoints, and a 429 means the workspace minute limit. Parsing the body alone makes both look like a person who does not exist. |
| A record update block | Your own objects and attributes | Custom objects included, which is the reason to be on Attio. The enriched attributes sit beside the ones a rep maintains instead of competing with them for the same field. |
| Delay and Loop blocks | A bounded poll, if you insist | Delay takes seconds through weeks, and Loop iterates a list with an optional limit rather than repeating until a condition. So a poll is constructible and ugly, and this is not where live resolution belongs. |
| Anything outbound to Reverse Contact | Nothing at all | This is a read layer. No Attio record or attribute is sent anywhere, and there is nothing in the product to send it to. |

### Two documented notes that together decide how this workflow behaves on a miss

These two sit a few lines apart in Attio's block library and they are the most useful thing on the page, because between them they describe exactly what happens when a data provider has no answer. One failure mode is silent and correct; the other is loud and is your mistake.

| What Attio documents about Parse JSON | What it means when the lookup found nobody |
|---|---|
| A path that evaluates to nothing returns an empty value and will not fail | An unresolved lookup leaves the field empty and the workflow carries on. This is the behaviour you want from a provider that returns null rather than a best guess |
| The output type must match what the path evaluates to, or it will fail | A headline declared as a Number fails the block outright. So a miss is quiet and a mistyped field is loud, which is the right way round |
| The block provides the status code as well as the body | The only way to tell an honest null from a 402 below 2 credits or a 429 at the minute limit. Branch on the code first |
| String maps to Text, Email, Domain, Select, Multi-Select, Currency, Status and Phone | Most of a person record is a String, so most fields are straightforward. An employee count and a follower count are the ones to declare as Numbers |
| The Send HTTP request timeout is 20 seconds | Comfortable against a published 500ms P95 on the cached endpoints, and nowhere near enough for a live job |
| These blocks are labelled Legacy while the builder is reworked | They are documented and they work. It is a fair signal that the configuration may move, so a build resting on exact field names is worth re-checking |

**What does not cross:**

- The live endpoints, sensibly. They answer with a task id, the HTTP block times out at 20 seconds, and a live job is documented as usually seconds and possibly tens of minutes.
- A business email or a direct phone number. Both are separate endpoints at 3 and 20 credits, charged only when one is found, and the email finder is asynchronous as well.
- A bulk backfill. Workflows are triggered per record, so the back catalogue belongs in Clay or n8n reading and writing through the Attio REST API.
- Anything travelling back to Reverse Contact. The direction runs one way, and there is nothing in the product to write to.

## Connect it, in this order

**Who has to do it:** Whoever can edit a workflow in Attio, plus whoever can create a Reverse Contact API key. No engineer, which is the point of this route.
**How long:** An hour. Most of it is deciding the Parse JSON paths and output types, which is the part that fails if rushed.

### 1. Confirm the workspace has automations, because the free plan does not

*Where:* Attio: plan and billing

Attio has a free plan and puts automations on the paid ones, so this whole route depends on one. The REST API is available either way, which is the fallback if the plan is not there yet, and it is a different build with an engineer in it.

### 2. Model the attributes before you build the workflow

*Where:* Attio: the object, Attributes

This is the reason to be on Attio at all and it is the step people skip. Create attributes that belong to the data provider, beside the ones a rep owns, rather than deciding which of somebody else's fields the enrichment is allowed to overwrite. Doing it first also tells you which Parse JSON output types you need.

### 3. Check which output type each value needs, from the three on offer

*Where:* Attio: Parse JSON, Output Type

There are three: Boolean maps to a Checkbox attribute, Number and Number (Array) map to Number and Rating, and String and String (Array) map to Text, Email Address, Domain, Select, Multi-Select, Currency, Status and Phone. An employee count is a Number and a headline is a String, and getting that pairing wrong fails the block rather than writing nothing.

### 4. Add the Send HTTP request block and test the Authorization header first

*Where:* Attio: Send HTTP request

Method POST, the URL, a Content-Type header because the request has a body, and Authorization set to Bearer plus your key. Attio supports custom headers, states that forbidden header names are not supported, and says it may block others for platform security, so prove this one works before building the rest.

### 5. Read the status code before you read the body

*Where:* Attio: the block's response variables

The block provides the response status code and the body as variable inputs for later blocks. Branch on the status with a Condition block: a 402 means the credit balance is gone, a 429 means the workspace minute limit, and both look like an empty profile if you only ever parse the body.

### 6. Write the Parse JSON paths in JavaScript traversal syntax

*Where:* Attio: Parse JSON, Path

A root key is just the key name, a nested value is every key joined by dots, and an array element uses the index in brackets. Attio documents that a path evaluating to nothing returns an empty value rather than failing, which is exactly the right behaviour for a provider that returns null rather than a guess.

### 7. Decide what an empty answer does, then wire the write

*Where:* Attio: a Condition, then a record update

An unresolved lookup arrives as empty fields, so the record update block will happily write nothing over something. Put the condition before the write rather than after it, and the workflow stops being able to erase a value a rep typed.

### 8. Keep live resolution out of this workflow

*Where:* Attio: not here

The Send HTTP request block has a 20-second timeout, and a live job answers with a task id and is documented as usually seconds and possibly tens of minutes. Attio does have Delay and Loop blocks, so a bounded poll is constructible, and it is still the wrong place for it.

Three of those eight are about types and paths, which is where this route actually fails: the call is easy and the parse is fussy. That is the trade for having no middle layer, and it is a better trade than the one [Pipedrive offers](pair:pipedrive+reverse-contact), where the response cannot be read at all.

## How to check it worked

- Run the workflow on a record whose answer you know, then on an email that resolves to nobody. The second should leave the attributes empty rather than failing, because a path that evaluates to nothing returns an empty value.
- Set one Parse JSON field to the wrong output type on purpose, a headline declared as a Number, and watch the block fail. That is the one failure mode here that is loud, and seeing it once tells you what the error looks like.
- Point the Send HTTP request block at the free check endpoint and read the update date it returns. It costs nothing, it proves the Authorization header is not being stripped, and the date is what decides whether you ever want a live refresh.
- Run it twice on the same record and confirm the second run overwrites nothing a rep owns. If the enrichment attributes are separate from the rep ones, as step two set them up to be, this is boring, which is the result you want.

## 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 Parse JSON block failed and the workflow stopped | Attio states that the output type must match what the path evaluates to or it will fail, and gives setting a name path as a Number as the example. | Check the type against the three on offer. Most of a person record is a String; an employee count and a follower count are Numbers, and an is-open-to-work flag is a Boolean. |
| The attributes came back empty and nothing errored | That is the documented behaviour of both halves. Reverse Contact returns null rather than a best guess, and Attio states that a path evaluating to nothing returns an empty value and will not fail. | Nothing is broken. Put a Condition block before the record update so an empty answer writes nothing, rather than writing nothing over something. |
| A value a rep typed has been replaced by a blank | The record update block wrote the empty result of an unresolved lookup, because no condition stood between them. | Condition first, write second, and keep the provider's attributes separate from the ones a rep owns. The second half of that is why the attribute modelling is step two of the setup rather than an afterthought. |
| The request is rejected and the header looks right | Attio supports custom headers, states that forbidden header names are not supported, and says it may block others as needed to maintain platform security. | Test the Authorization header on the free check endpoint, which costs nothing. If it is being stripped you want to know that before the rest of the workflow exists. |
| Everything stopped at once, including the free checks | Below 2 credits Reverse Contact pauses the free Check endpoints too and answers 402 NO_CREDITS, because the fetch a check precedes can itself cost 2. | Branch on the status code, which the HTTP block hands you alongside the body. GET /v2/usage keeps answering whatever the balance, so a scheduled workflow can watch the balance even when nothing else works. |
| A 429 on a workflow that was fine yesterday | Reverse Contact applies a minute limit per workspace, shared with every other integration on it, and answers 429 past it. | Read quotas.minuteRateLimit from the body for limit, used, left and nextReset, and give this workflow its own key with a per-key cap so it cannot starve a Clay table running beside it. |
| The HTTP block timed out | Attio documents a 20-second timeout on Send HTTP request, and the live endpoints answer with a task rather than a record. | Use the cached endpoints here, which publish a 500ms P95. Live resolution belongs in n8n, and the Attio REST API is how the answer comes back when it arrives. |
| An endpoint that worked last week returns nothing | /v2/resolve was replaced by /v2/enrich and /v2/search/persons by /v2/search/people, with the old pair documented as live only until 13 October 2026. | Open the Send HTTP request block and change the URL. It is a hard-coded string in a workflow rather than a configuration setting, so nothing will warn you that it has stopped resolving. |

## What breaks, from the vendors' own docs

- **Twenty seconds on the HTTP block.** Attio documents a 20-second timeout on Send HTTP request. A cached reverse lookup fits comfortably against a published 500ms P95. Anything that answers with a task to poll does not, and while Attio does have Delay and Loop blocks, Loop iterates a list with an optional limit rather than repeating until a condition is met. A bounded poll is therefore constructible and awkward, and live resolution still belongs somewhere else.
- **Parse JSON fails on a type mismatch.** Each extracted field declares an output type, and Attio states that a type which does not match what the path evaluates to will fail. A field that is sometimes null and sometimes a string is exactly the shape a data layer returns, so decide what an unresolved lookup does before you add the block.
- **Attio labels these blocks legacy.** The block library lists Send HTTP request and Parse JSON as legacy while Attio reworks its workflow builder. They are documented and they work, and it is a fair signal that the configuration may move. Worth knowing before a build rests on the exact field names.
- **Some headers are blocked.** Custom headers are supported, and Attio states that certain headers are not and that others may be blocked as needed for platform security. The Authorization header this needs is ordinary, and it is still the first thing to test rather than assume.
- **Automations are a paid feature.** Attio has a free plan and automations are on the paid plans, so the route on this page needs one. The REST API is available either way, which is the fallback if the plan is not there yet.

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

- Attio: legacy workflows block library: https://attio.com/help/reference/automations/legacy-workflows/legacy-workflows-block-library
- Attio Academy: HTTP and JSON blocks: https://attio.com/help/academy/workflows-course/http-and-json-blocks
- 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
- Pipedrive: automations webhook requests: https://support.pipedrive.com/en/article/automations-webhook-requests
- Zoho CRM: functions platform limits and quotas: https://www.zoho.com/crm/developer/docs/functions/limits-quotas.html
- HubSpot developers: custom code workflow actions: https://developers.hubspot.com/docs/api-reference/legacy/automation/workflow-actions/custom-code-actions
- 14 practitioner threads read on 2026-10-11, summarised on the page: https://www.reversecontact.com/integrations-hub/attio-integrations/attio-reverse-contact-integration#reddit
- This pair, with the reasoning behind each step: https://www.reversecontact.com/integrations-hub/attio-integrations/attio-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.*
