Attio and Reverse Contact

Featured

The one CRM here whose own workflow can call the API and read the answer.

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, in.

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.

What actually syncs

Object by object, with the direction each one moves in. This is the table to read before the feature list, because a capability that only moves one way is a different product from the one you think you are buying.

WhatDirectionWhat 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.

Nothing in that table moves in both directions. Whichever system you treat as the source of record, the other one is downstream of it, and a correction made in the wrong place does not travel.

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 AttioIn Reverse ContactWhat 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 JSONWhat it means when the lookup found nobody
A path that evaluates to nothing returns an empty value and will not failAn 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 failA 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 bodyThe 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 PhoneMost 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 secondsComfortable 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 reworkedThey 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

A few things are worth knowing before you plan around this mapping, because each one is a decision somebody has to own rather than a setting to find.

  • 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.

Every row above travels as a file: eight field mappings, six what attio documents about parse json rows and four documented exclusions, each one's note, and the nine vendor documents behind them. The CSV opens in a spreadsheet, the JSON is the shape an agent wants, and the Markdown is the table to paste into a ticket.

Field map

The two notes at the top of that table are what make this route safe to leave running. A provider that returns null rather than a guess, meeting a parser that treats an empty path as an empty value, means the common case of no answer is handled by both sides agreeing to do nothing, which is rarer than it should be.

Which CRM can run the whole enrichment in its own builder

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. Pick one on each side and the grid marks the answer.

Pick one on each side.

The CRMCall an outside API from its own automationRead the response in a later stepWithout writing any codeWithout 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.

How to connect Attio to Reverse Contact

Every step below is from the two vendors' own setup documentation, in the order they document it. Two of them cost you an afternoon if taken late, so the order is the useful part rather than the clicks.

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 it takes
An hour. Most of it is deciding the Parse JSON paths and output types, which is the part that fails if rushed.
Setup checklist 0 of 8 done

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.

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.

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.

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.

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.

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.

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.

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, where the response cannot be read at all.

Hand it to an agent instead

The same sequence, the sync table, the documented limits and the error list ship as one agent skill. Point Claude Code, Cursor or anything that reads a file at this pair as a skill and it has the whole pair without reading two sets of vendor docs first.

curl -o .claude/skills/attio-reverse-contact/SKILL.md https://www.reversecontact.com/integrations-hub/skills/attio-reverse-contact.md

What breaks, and what nobody tells you

Every limit below is documented by one of the two vendors. They are here because they change decisions, not because they are flaws.

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.

Each of those is documented behaviour rather than a fault, so none of them is going to be fixed by a support ticket. The ones that produce a symptom you would misread are below.

The 8 failures people actually hit

Each one below is a symptom somebody reports, the documented reason behind it, and the fix. Most are configuration rather than faults, which is why they survive a support ticket.

01

The Parse JSON block failed and the workflow stopped

WhyAttio 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.

02

The attributes came back empty and nothing errored

WhyThat 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.

03

A value a rep typed has been replaced by a blank

WhyThe 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.

04

The request is rejected and the header looks right

WhyAttio 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.

05

Everything stopped at once, including the free checks

WhyBelow 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.

06

A 429 on a workflow that was fine yesterday

WhyReverse 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.

07

The HTTP block timed out

WhyAttio 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.

08

An endpoint that worked last week returns nothing

Why/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.

If none of those is it, the next thing to check is the thing most pairs fail on: whether the plan you are on carries the feature at all, which the grid above answers. The same symptom on another pair is often the same cause, so the directory indexes all of them by the message rather than by the integration.

When this is the right integration

Set it up when

  • Enriching custom objects you modelled yourself
  • A team that wants no middle layer and has no engineer
  • Reading the response and branching on it inside the CRM

Do not bother when

  • Live resolution, which needs a polling loop
  • A bulk backfill across the whole workspace
  • You are on the free plan and have no automations

The right-hand column is the one worth being honest about, because every item in it is a reason to spend the budget somewhere else in the stack rather than a reason to configure harder.

What practitioners say about it

Searched for the problem this pair solves rather than for the pair itself, because the pair by name returns almost nothing. 14 threads from 2024 to 2026 were read in full on 11 October 2026, and the 5 below are the ones that carry a point. Each is one person's experience rather than a measurement, and the vendors' own documentation is what the rest of this page rests on.

Somebody recommending this build, by name and for the right reason

To avoid violating LinkedIn's ToS look for a CRM that treats enrichment as part of the record. You want it to use Al to fill fields you can use to filter. Attio would work for this because it lets you build out the attributes you want then populate them with information from LinkedIn if it's publicly available. You can also do something similar with other CRMS and an automation tool. Like Hubspot with a Zapier webhook for example

r/b2bmarketing·March 2026·2 points

Answering somebody who spends their whole day doing prospecting research by hand. The reason given for Attio is the right one and it is not the HTTP block: it is that the attributes are yours, so enrichment becomes part of the record rather than a competitor for somebody else's fields. The second half concedes the fallback, which is the route most of the CRMs in this directory are stuck with.

Reps should not be maintaining the CRM at all

Once a team gets past a certain size, relying on people to stay perfectly disciplined just doesn't hold. [...] Automate the unglamorous stuff (enrichment, normalization, auto-updating stages when nothing's happened in a while) [...] The biggest shift for us was realizing reps shouldn't be maintaining the CRM at all. Their job is to work deals.

r/CRMSoftware·February 2026·3 points

From somebody who describes having lived through more CRMs than they would like to admit. The last sentence is the premise of every page in this block, and the middle one names enrichment as unglamorous automation rather than as a feature, which is the correct register for a workflow that runs three blocks and writes four attributes.

Capture it without the rep's help, and judge it on friction

Make as little friction for your sales people as possible. Capture as much info as you can without their help, clean data and reports on the backside & those who want to win begin paying attention to the reports and predictions you're making & thrive.

r/CRMSoftware·January 2026·1 points

From somebody who ran business intelligence and information systems at a mid-sized company and came to it after years of frustration. It is the clearest statement of what to measure: not how complete the record is, but how little the rep had to do to make it so. A workflow that fires on record creation scores well on that test by construction.

Given an Attio workspace, the advice is an API and a workflow engine

According to the fact that you have attio and it has a perfect api, you can build rotating system and scrape li data using n8n. Key steps: - take contacts by some period of time - scrape li data using some budget friendly apis - push data back

r/CRM·October 2025·1 points

Answering an Attio user who wanted connection dates and message counts synced automatically. The advice is sound for a backfill and it is the route this page recommends for one, because a workflow fires per record and a rotating sweep belongs outside. Note that the scraping half is a different proposition from calling a provider's API, and the two have different answers from a legal team.

One primary identifier per record is what makes any of this match

One person (or a tiny ops function) owns the rules of the game: what a "customer" means vs lead vs vendor, what fields are mandatory, how phone numbers are stored (E.164 format helps a lot), what counts as a duplicate, and what the lifecycle states are [...] use picklists instead of free-text for key fields

r/CRMSoftware·January 2026·1 points

The picklist advice connects directly to the Parse JSON table above, because a String output type maps to a Select attribute and a value that does not exist in the picklist is a value that will not land. Deciding the allowed values before the workflow writes to them is the version of this rule that matters here.

What the threads add up to

Nobody discusses this pair by name, so the search was for the job: keeping a CRM current without reps maintaining it. One comment recommends this exact build to a stranger, naming Attio and the reason, which is as close to a review of this page as the threads get. The rest converge on a single idea, that data quality is a system design problem rather than a discipline problem.

The first quote is the closest thing in the harvest to a review of this pair, and the reason it gives is the data model rather than the HTTP block. That is the right order: the twenty minutes the block saves are pleasant, and attributes that belong to the provider rather than to a rep are what keeps the pair working a year later, which is the argument the field table makes with Attio's own documentation.

The longer answer

Put this page next to the Pipedrive one and the difference is the whole argument of this directory: both are mid-market CRMs with an automation builder and a webhook action. Attio's HTTP block hands the response status and body to the next step, so an enrichment is one workflow. Pipedrive's fires a request and cannot read what comes back, so the same enrichment is a webhook out, a worker somewhere else, and a write back in through the API. Nothing on either vendor's feature list says this, and it is the fact that decides a day of work.

What Attio buys with its data model is the part that outlasts the build. Enriching into a CRM with a fixed contact schema means deciding which of somebody else's fields your data provider is allowed to overwrite. Enriching into objects you defined means adding attributes that belong to the provider, keeping them beside the ones a rep owns, and never having that argument. That is worth more than the twenty minutes the HTTP block saves.

The route that does not change is the one outside the CRM. Where the job is a backfill, a waterfall or anything live, the answer here is the same as it is for Salesforce and for every other CRM in this directory: do it in Clay or n8n and write the result in. The native app on Zapier is the no-code version of the same move, and it is the one most of the CRMs with no HTTP block of their own end up using.

Checked by

Reverse Contact

We sell B2B people and company data, and we publish this directory. Every tier requirement, sync direction and limit on this page was read from a vendor's own knowledge base, developer documentation or pricing page on the date below. Nothing on it is restated from a press release or a third-party listing.

Where a vendor publishes no public figure, this page says so rather than estimating, which is why no page here prints a cost per enriched record. Reverse Contact appears in this directory as a data provider and publishes it. No other vendor pays for placement, and every link out of a listing or a citation carries nofollow, including the ones that point at Reverse Contact. The only followed links on this page are the two calls to action and the reviewer.

One fact about the publisher, stated here rather than in the page above it: Reverse Contact has no CRM marketplace app and no app inside a sequencer. Its three native apps are on Clay, Zapier and Make, and every other route is its API, its CLI or its MCP server. That is a deliberate shape for a data layer rather than a missing release, and it is what the routes on this page are describing.

Tier requirements, sync behaviour and documented limits change without notice. Confirm against your own contract before you budget. What has changed since · How we checked, and what we will not claim

Researched and written by

Eugene Suslov

Researched and wrote every page in this directory, and checked every tier requirement, sync direction and documented limit against the vendor's own knowledge base, developer documentation or pricing page.

Verified
2026-10-11
Sources
9 vendor documents
Paid placement
None

The integration moves the record. Something has to fill it.

Reverse Contact resolves an email, a domain or a profile URL into a verified people and company record, through one API with a consistent schema. It sits under Attio, Reverse Contact and everything else in this directory, and it returns null with a confidence score rather than a guess.

Free trial, no card required, and 500 credits to start.

Attio and Reverse Contact, asked and answered

Is there an Attio and Reverse Contact integration?

Not as an app, and Attio is the one CRM here that does not need one. Its Send HTTP request block calls the API and hands the response status and body to the next block, a Parse JSON block turns that body into named fields, and a record update block writes them onto your own objects, custom ones included. Three blocks, no middle layer and no second meter, which is a different answer from every other CRM in this directory.

Can an Attio workflow call Reverse Contact directly?

Yes, and this is the thing that sets Attio apart in this directory. The Send HTTP request block supports GET, POST, PUT, PATCH, DELETE and HEAD with custom headers and a body, and it provides the response status code and body as variables for later blocks. A Parse JSON block then pulls named fields out of the response. The whole enrichment happens inside Attio with nothing in the middle.

What is the timeout?

Twenty seconds on the Send HTTP request block, which Attio documents. A cached reverse lookup returns comfortably inside that. The live endpoints do not, because they return a task to poll rather than a record, so live resolution belongs outside Attio.

How does Parse JSON work?

You declare a field per value you want, give each a property path in the same syntax you would use to walk the object in JavaScript, and set the expected output type. A type that does not match what the path evaluates to fails the block, so a path pointing at a string declared as a number breaks the workflow rather than writing nothing.

Does it enrich custom objects?

Yes, and that is the reason to use Attio in the first place. Objects and attributes are yours, so the enriched fields land on whatever you modelled rather than on somebody else's idea of a contact. The workflow writes them with a record update block like any other value.

Tier requirements, sync behaviour and limits read from each vendor's own documentation in September, October and November 2026. Vendors change these without notice.

Reverse Contact appears in this directory as a data provider and publishes it. Every other tool is here on merit and nobody pays for placement.

Ask an assistant