Menu

Mattering Automations Attio integration

Connect Attio to Mattering Automations: objects and attributes, records with upsert and value history, lists and list entries, notes, tasks, comments, meetings, call recordings, files and webhooks as workflow steps, authenticated with one scoped workspace API key.

The Mattering Automations Attio integration puts 76 Attio nodes on your automation canvas: read and write records on any object, upsert on a unique attribute so a retry does not duplicate, manage lists and list entries with their own stage and owner attributes, read and replace attribute value history, write notes and tasks, comment on records and threads, sync meetings and call recordings with transcripts, manage files and folders, and register webhooks.

The credential is one workspace API key, created in Attio's workspace settings under the developer section and sent as an Authorization bearer header on every request. You choose the scopes the key carries when you create it, and Attio lets you edit them afterwards rather than forcing a new key. There is nothing else to supply: no version header, no company domain, no second field. Setup takes a few minutes, and this guide walks through each step and ends with the full node reference.

One thing about Attio is different from most CRM integrations, and it is easier to understand up front than to hit later. Attio has NO fixed schema: objects, attributes, lists and entries are all workspace defined, so this integration cannot ship a hard coded field list and does not try to. The nodes discover your workspace at run time through dependent pickers instead. Choosing an object in Object narrows the Attribute picker to attributes that exist on that object, and choosing an attribute narrows the select option and status pickers below it. Lists work the same way down to their entries. Record pickers read from Attio: Search Records rather than from the record lister, because a record's values come back as a map keyed by attribute slug that no path expression can fan out over, and search is the one place Attio hands back the display name it renders itself.

Before you start

  • An Attio workspace you can create an access token in. Tokens are created in workspace settings under the developer section, where the scopes are chosen.
  • A decision about scopes. Attio declares required scopes per endpoint family: object configuration, record permission, list configuration, list entry, user management, note, task, comment, email, meeting, call recording, file and webhook, each available read only or read and write. Grant only the families your workflows need. A narrow key still passes Test Connection, because the probe is the one operation in Attio's specification that requires no scopes at all, so scope problems surface on the first real node rather than at connection time.
  • An Attio plan that covers the nodes you intend to use. Attio's pricing comparison lists API and webhook access on every tier including Free, so the base of this catalog is not plan gated; confirm the current split on Attio's own pricing page before designing around it. Two exceptions are documented: Attio: Query SQL states in Attio's own specification that the workspace must be on the Enterprise plan, and creating or updating a list with advanced workspace access or per member access can be refused with a billing error on plans without that feature, while list creation with plain full access works.
  • Awareness of what is not generally available. Attio: List Emails is documented as alpha and enabled per workspace and per app on request to Attio's support team, so a token that works everywhere else can be refused there. Attio documents meetings, call recordings, files, record search and read only SQL as beta: live and callable, with Attio reserving the right to make small changes.
  • A Mattering workspace with access to the Automations app.

Create an Attio workspace API key

Attio takes one static token in one header on every request, sent as an Authorization bearer header. The token belongs to a workspace, so the first decision is which workspace this credential should reach and the second is which scopes it should carry. Attio also accepts HTTP Basic with the token as the username as a documented fallback, but bearer is the stated preference and the only form this integration uses.

Sign in to Attio and open the workspace this credential should reach.
Open Workspace settings, go to Developers, and create an access token.
Choose the scopes your workflows need, then copy the token value.
Scopes can be edited after the token exists, so a key that turns out to be too narrow does not have to be replaced. Start narrow: read only scopes are enough for reporting workflows, and nothing in a read only key can reach the destructive nodes.
A token with record write scope can reach deletes, and Attio's deletes are final. Attio's own archiving guide states that deleted data is eventually removed entirely with no ability to restore it, so there is no trash and no restore window behind these nodes. If this credential exists for reporting or enrichment, do not grant write scopes it does not need.

Connect Attio to Mattering

In Mattering Automations, open Connectors and click Add Connector.
Choose Attio from the list.
Click Create new credential, paste the token, and save.
The credential is stored encrypted in Google Secret Manager and never appears in workflow logs.
Click Test Connection. Mattering calls Attio's token introspection endpoint, which is the only operation in Attio's whole specification that declares no required scopes, so a deliberately narrow key passes for the right reasons rather than failing for a wiring reason. On success the response names the workspace the token belongs to and reports the scopes it carries.
Click Connect. All 76 Attio nodes appear in your canvas palette.

Verify it works

After connecting, open any automation canvas and check the palette: an Attio section should list the read and action nodes. Drop Attio: Identify Token onto the canvas and run a test step. It needs no parameters, and it returns the workspace name and slug plus the scope string the token carries, which is the fastest way to confirm the scopes are the ones you meant to grant. Read one field carefully before you move on, because this is the Attio specific check most people skip: the response carries an active flag, and a revoked or malformed token can answer HTTP 200 with that flag set to false. A 200 alone is not proof. Assert that the active flag is true.

Now try a scoped node, because that is where the schema discovery shows itself. Drop Attio: List Objects onto the canvas and run a test step: you get every object in the workspace, both the ones Attio ships and any your workspace defined, each with its slug and its singular and plural nouns. Then drop Attio: List Attributes and open its Object field: the picker should list your objects, and choosing one should narrow the attribute list to attributes that actually exist on it, grouped by attribute type. Everything in this verify path is read only, so it cannot reach the 11 destructive nodes and is safe to re run whenever you rotate the token.

Node reference

76 nodes, generated from the connector itself so this reference always matches what ships.

Read and query nodes 38

Attio: Get Attribute

attio_get_attribute

Get one attribute's full definition: type, whether it is writable, required, unique or multiselect, its default value, its type-specific config, and for a record-reference attribute the reverse relationship it is entangled with.

Attio: Get Call Recording

attio_get_call_recording

Get one call recording with its full transcript: timed segments with speaker attribution at data.data.transcript.segments[], plus a flat readable version at data.data.transcript.raw_transcript, and the video URL if there is one. This is the node to feed a summariser. Documented as beta.

Attio: Get Comment

attio_get_comment

Get one comment by id, with its author, text, thread, the record or entry it sits on, and whether it has been resolved.

Attio: Get File

attio_get_file

Get one file or folder entry by id, with its name, content type and size, its storage provider, and the record it hangs off. Returns the metadata, not the bytes. Documented as beta.

Attio: Get List

attio_get_list

Get one list by slug or id, with its parent object and the workspace and per-member access levels. Read the parent object before adding entries: a list only accepts records of that object.

Attio: Get List Entry

attio_get_entry

Get one list entry by id, with its parent record and every list-specific attribute value. Read data.data.parent_record_id to jump from the entry back to the record it represents.

Attio: Get Meeting

attio_get_meeting

Get one meeting by id with its title, description, start and end, participants and their RSVP status, and linked records. Documented as beta.

Attio: Get Note

attio_get_note

Get one note by id, in both plaintext and markdown, with the record it belongs to, the meeting it is linked to if any, and the records and members it tags.

Attio: Get Object

attio_get_object

Get one object by slug or id, with its api_slug, singular and plural nouns and creation time. Use it to resolve a slug to the stable object_id before saving a reference that must survive someone renaming the object in the UI.

Attio: Get Record

attio_get_record

Get one record by id, with every attribute's current value and the record's web_url for linking a human straight to it. As with the lister, data.values is keyed by attribute slug, so a company's name reads as data.data.values.name[0].value.

Attio: Get Task

attio_get_task

Get one task by id, with its content, deadline, completion state, assignees and the records it links to.

Attio: Get Thread

attio_get_thread

Get one thread with every comment in it, each with its author, text, creation time and whether the thread has been resolved.

Attio: Get Webhook

attio_get_webhook

Get one webhook with its target URL, subscriptions, filters and status. The signing secret is not echoed.

Attio: Get Workspace Member

attio_get_workspace_member

Get one workspace member by id. Useful for turning the actor id that appears all over Attio's responses (created_by_actor.id) into a name and an email address a notification can address.

Attio: Identify Token

attio_identify

Introspect the access token: whether it is active, the scopes it carries, and the workspace it belongs to by id, name and slug. This is the cheapest authenticated read Attio offers and the only endpoint that needs no scopes at all, which makes it the right connection test. Note that a revoked token can answer HTTP 200 with active false rather than 401, so check data.active, not just the status code.

Attio: List All Lists

attio_list_lists

List every list the token can see, in sidebar order, with each one's slug, name, parent object and access settings. A list in Attio is a pipeline or a working set: records are added to it as ENTRIES, and each entry carries its own attributes such as stage or owner. This is what every list picker reads.

Attio: List Attributes

attio_list_attributes

List the attributes defined on one object or one list, in the order the UI sorts them, with each attribute's slug, title, type and whether it is required, unique, multiselect or a system attribute. Because Attio's schema is workspace-defined, this is how you discover the keys a record's values object will accept, and it is what every attribute picker reads.

Attio: List Call Recordings

attio_list_call_recordings

List the call recordings attached to a meeting, with each one's processing status and a web URL into Attio. The transcript itself is not in the list payload; fetch one recording to get it. Documented as beta. Cursor-paginated.

Attio: List Emails

attio_list_emails

List email METADATA from the workspace's connected mailboxes: who, when, which direction, what subject line, and which records the message is linked to. Message content is never returned. Three things to know before wiring it up. It is documented as ALPHA and is enabled per workspace and per app on request to Attio support, so it can 403 on a token that works everywhere else. It refuses to list everything: supply at least one of linked records, participants or domain. And filters that identify your own workspace are ignored, so filtering by a colleague's address returns nothing.

Attio: List Entries

attio_list_entries

Query the entries in one list with a filter and a sort order. An entry is a record's membership of that list plus the list-specific attributes attached to it, so this is where pipeline stage, owner and deal-specific fields live. As with records, data.data[].entry_values is keyed by attribute slug rather than being a list. POST because the filter goes in the body; nothing is written.

Attio: List Entry Attribute Values

attio_list_entry_attribute_values

Read one attribute's values on one list entry, optionally including the full history oldest first. This is how you reconstruct a deal's stage history: each value carries active_from and active_until, so the gaps between them are the time the entry spent in each stage.

Attio: List Files

attio_list_files

List the files and folders attached to ONE record: both files stored in Attio itself and folders connected from Dropbox, Box, Google Drive or OneDrive. The object and record id are required, so there is no way to list a workspace's files as a whole. Documented as beta. Cursor-paginated.

Attio: List List Views

attio_list_list_views

List the saved views on a list, ordered by view id. Feed a view id to Attio: List Entries to reproduce exactly the filtered board a person sees in the UI. Cursor-paginated.

Attio: List Meetings

attio_list_meetings

List meetings with their participants, times and linked records, filtered by date window, participant or linked record. Note that participants and linked_record_id are combined with OR, not AND, so supplying both widens the result rather than narrowing it. Documented as beta. Cursor-paginated.

Attio: List Notes

attio_list_notes

List notes across the whole workspace, or narrow to one record by supplying both the parent object and the parent record id. Each note comes back in both plaintext and markdown, with the records and members it tags, which makes this a good feed for summarisation.

Attio: List Object Views

attio_list_object_views

List the saved views on an object, ordered by view id. A view carries a filter configuration someone built in the UI, so feeding a view id to Attio: List Records reproduces exactly what a person sees on screen without rebuilding the filter in JSON. Cursor-paginated.

Attio: List Objects

attio_list_objects

List every object in the workspace, both the ones Attio ships (people, companies, deals, users, workspaces) and any the workspace has defined itself, with each one's api_slug and singular and plural nouns. Attio has no fixed schema, so this is the node everything else leans on: it is what an object picker reads, and running it is how you find out what a workspace actually models.

Attio: List Record Attribute Values

attio_list_record_attribute_values

Read one attribute's values on one record, optionally including every historic value rather than just the current one. Attio keeps value history with active_from and active_until timestamps, so this is how you answer questions like when a deal changed stage or what a job title used to be. Historic values are returned oldest first, and are not available for communication-intelligence or enriched attributes, which return 400 instead.

Attio: List Record Entries

attio_list_record_entries

List every list entry, across every list, whose parent is this record. This is how you answer which pipelines a company is currently in, and it returns each list's id and slug alongside the entry id so a follow-up node can read or update the entry.

Attio: List Records

attio_list_records

Query records of one object with a filter and a sort order. This is the workhorse read: strongly consistent, unlike search, so it is what to use when a workflow has just written something and needs to see it. Note that data.data[].values is an object keyed by attribute slug rather than a list, so a person's name reads as data.data[0].values.name[0].full_name. It is a POST because the filter goes in the body; nothing is written.

Attio: List Select Options

attio_list_select_options

List the options a select attribute offers, with each option's title, id and archived flag. Run this before writing to a select attribute: Attio matches on the option title, so a typo silently fails rather than creating a new option.

Attio: List Statuses

attio_list_statuses

List the statuses a status attribute offers, with each one's title, id, celebration flag and target time in status. This is the pipeline vocabulary for a list or object, so run it before moving anything between stages.

Attio: List Tasks

attio_list_tasks

List tasks, filtered by assignee, completion state, or the record they are linked to, and sorted by creation or completion time. This is the read behind an overdue-task digest or a per-owner workload report.

Attio: List Threads

attio_list_threads

List comment threads, optionally narrowed to one record (pass the object and record id) or one list entry (pass the list and entry id). Each thread arrives with its comments nested inside, so a single call gives you the whole conversation at data.data[].comments[]. This is also the only lister that surfaces comment ids.

Attio: List Webhooks

attio_list_webhooks

List the workspace's webhooks with their target URLs, event subscriptions and status. The signing secret is returned only when a webhook is created, never here, so this is safe to run in a shared workflow.

Attio: List Workspace Members

attio_list_workspace_members

List everyone in the workspace with their name, email address, avatar and access level. Workspace members are the only actors that can own a task or author a comment, so this is what every assignee and author picker reads. The API is read-only here: members are invited and removed in the Attio UI.

Attio: Query SQL

attio_query_sql

Run a read-only SQL query across records and lists and get back flat rows, which is the one node here whose output drops straight into a chart or a spreadsheet without walking Attio's value envelopes. ENTERPRISE ONLY: Attio gates this endpoint to Enterprise workspaces and any other plan gets an error, and it is documented as beta.

Attio: Search Records

attio_search_records

Fuzzy-search records across one or more objects the way the Attio search bar does, matching names, domains, email addresses, phone numbers and social handles on people and companies, and labels on everything else. It returns a record_text display name for each hit, which is why every record picker in this connector reads from here rather than from the record lister. Two caveats: it is documented as beta, and results are EVENTUALLY CONSISTENT, so use Attio: List Records when you need to see a write you just made.

Action nodes 38

Attio: Add Record To List

attio_create_entry

Add an existing record to a list as a new entry, setting the list's own attributes at the same time. This ALWAYS creates, and Attio explicitly allows several entries for the same parent record, so calling it twice gives you two entries. Use Attio: Upsert List Entry when a workflow might run twice.

Attio: Create Attribute

attio_create_attribute

Add an attribute to an object or a list. The type decides what config the attribute accepts and cannot be changed afterwards. For a record-reference attribute you can pass a relationship object to create a bidirectional pair, which creates a second, entangled attribute on the other object. Attributes are archived rather than deleted, so this is reversible in the sense that it can be hidden, not removed.

Attio: Create Call Recording

attio_create_call_recording

Attach a recording and transcript to a meeting, which is how an external notetaker gets its output into Attio. Always send the transcript: it is optional only for backwards compatibility, and a recording without one has no summaries and none of the transcript-derived features. The video is optional and Attio downloads it from your URL asynchronously. RATE LIMITED TO ONE REQUEST PER SECOND, well below the general write limit, so throttle a backfill. Documented as beta.

Attio: Create Comment

attio_create_comment

Post a comment. Supply EXACTLY ONE of thread_id (reply to an existing thread), record (start a thread on a record) or entry (start a thread on a list entry). Putting a workspace member's email address in the content NOTIFIES them, which is the mechanism for pinging an owner from a workflow; any other email address just becomes a mailto link. The author must be a workspace member, because Attio does not yet support other actor types here.

Attio: Create Folder

attio_create_folder

Create a folder on a record, or connect a file or folder that already lives in Dropbox, Box, Google Drive or OneDrive. For a native folder set file_type to folder and give it a name. To connect something external, set file_type to connected-folder or connected-file and supply the storage provider and that provider's own file id. Documented as beta. Note this body is NOT wrapped in a data envelope, unlike most Attio writes.

Attio: Create List

attio_create_list

Create a list and set who can see it. Attio requires that SOMEONE has full access: either workspace_access is full-access, or at least one entry in workspace_member_access has level full-access, otherwise the call is rejected. Per-member and advanced workspace access are plan-gated, so a workspace on a lower plan can get a 403 here. Add attributes afterwards with Attio: Create Attribute (target lists) and records with Attio: Create List Entry.

Attio: Create Meeting

attio_create_meeting

Record a meeting in Attio, which is how an external calendar or notetaker syncs its events in. Participants given by email address AUTOMATICALLY CREATE person and company records if they do not exist, so this node can grow the CRM as a side effect; participants given by name only do not. Attio has no built-in de-duplication here, so a re-run creates a second meeting. Documented as beta.

Attio: Create Note

attio_create_note

Write a note onto a record. This is the natural landing place for an AI-generated call summary or research brief: it accepts markdown, so headings and lists survive, and it can be backdated with created_at when migrating history in.

Attio: Create Object

attio_create_object

Create a custom object, which is Attio's equivalent of adding a new record type to the CRM. A new object starts with only its system attributes; add your own with Attio: Create Attribute. Attio ships no endpoint that deletes an object, so treat this as close to permanent even though it is not marked destructive.

Attio: Create Record

attio_create_record

Create a record. This ALWAYS creates: it throws on a conflict with a unique attribute rather than updating, so a workflow that might see the same person twice wants Attio: Upsert Record instead. The values object is keyed by attribute slug or id, and which keys are valid depends entirely on how the workspace has configured that object.

Attio: Create Select Option

attio_create_select_option

Add an option to a select attribute. Options are archived rather than deleted, so this only ever grows the vocabulary.

Attio: Create Status

attio_create_status

Add a status to a status attribute, which is how you add a stage to a pipeline. Statuses are archived rather than deleted.

Attio: Create Task

attio_create_task

Create a task, assign it and link it to records. The linked records array is unusually forgiving: it accepts a record id, a company domain, a person's email address, or a unique matching attribute, so a workflow can link a task to a person it only knows by email without looking the record up first. Content is PLAINTEXT ONLY at present, with no rich text, links or at-mentions.

Attio: Create Webhook

attio_create_webhook

Register a webhook so Attio pushes record, list-entry, note, task, comment and attribute events to a URL. THE RESPONSE IS THE ONLY TIME THE SIGNING SECRET IS RETURNED (data.data.secret): capture it in the same run or you have to recreate the webhook. Each combination of target URL, event type and filter must be unique in the workspace; a duplicate is rejected with 409.

Attio: Delete Call Recording

attio_delete_call_recording

DESTRUCTIVE AND IRREVERSIBLE. Delete a call recording and everything derived from it: the video, the transcript, and the summaries Attio generated from that transcript. The meeting itself survives. Unless you still hold the source recording elsewhere, this is unrecoverable. Answers HTTP 204 with no body. Documented as beta.

Attio: Delete Comment

attio_delete_comment

DESTRUCTIVE AND IRREVERSIBLE. Delete a comment. Blast radius worth reading twice: if the comment is the FIRST one in its thread, Attio deletes EVERY OTHER COMMENT in that thread too, including replies written by other people. Deleting a reply only removes that reply. There is no undo. Returns an empty object.

Attio: Delete File

attio_delete_file

DESTRUCTIVE AND IRREVERSIBLE. Delete a file or folder entry. DELETING A FOLDER DELETES EVERY DESCENDANT, files and subfolders alike, in one call and with no confirmation. For a file stored in Attio the bytes go with it; for a CONNECTED entry only Attio's link is removed and the file stays in Dropbox, Box, Drive or OneDrive. Check the file_type and storage_provider before running this. Documented as beta. Returns an empty object.

Attio: Delete List Entry

attio_delete_entry

DESTRUCTIVE AND IRREVERSIBLE. Remove an entry from a list, taking with it every list-specific attribute value on that entry and their history: the stage it reached, when it got there, who owned it. The underlying RECORD survives untouched, which is what makes this the right way to take something out of a pipeline rather than deleting the record. There is no undo, and re-adding the record creates a fresh entry with empty values. Returns an empty object.

Attio: Delete Note

attio_delete_note

DESTRUCTIVE AND IRREVERSIBLE. Delete a note and its content. Attio has no trash for notes and no restore, so a call summary deleted here is gone. The record it was attached to is unaffected. Returns an empty object.

Attio: Delete Record

attio_delete_record

DESTRUCTIVE AND IRREVERSIBLE. Delete a record and everything that hangs off it: every attribute value and its history, and the record's entries in every list it appears on. Attio has no trash and no restore window, and its own guidance is that deleted data is eventually removed from its servers entirely. Notes, tasks and comments that reference the record lose that reference. If what you want is to take a record out of a pipeline, delete its LIST ENTRY instead. Returns an empty object.

Attio: Delete Task

attio_delete_task

DESTRUCTIVE AND IRREVERSIBLE. Delete a task. There is no undo and no trash. If what you want is to mark work finished, set is_completed true with Attio: Update Task instead, which keeps the record of it. Returns an empty object.

Attio: Delete Webhook

attio_delete_webhook

DESTRUCTIVE AND IRREVERSIBLE. Delete a webhook and every subscription on it. Delivery stops immediately and the signing secret is destroyed with it, so recreating the webhook means distributing a NEW secret to whatever verifies the signatures. Events that happen while it is gone are not replayed. Returns an empty object.

Attio: Merge Records

attio_merge_records

DESTRUCTIVE AND IRREVERSIBLE. Merge two records into one. The SECONDARY record ceases to exist: its values survive only where the primary had none, and every conflict is resolved in the primary's favour, so the secondary's version of any contested attribute is lost. There is no unmerge. Run Attio: Get Record on both first if you want a copy of what is about to be discarded.

Attio: Overwrite List Entry Values

attio_overwrite_entry

Update a list entry, OVERWRITING multiselect attributes: for every multiselect attribute you mention the supplied list becomes the entire list, so anything omitted is removed. Attributes you do not mention are untouched. Use Attio: Update List Entry to add without removing.

Attio: Overwrite Record Values

attio_overwrite_record

Update a record, OVERWRITING multiselect attributes. For every multiselect attribute you mention, the supplied list becomes the entire list and anything not in it is removed, which is how you clear tags or replace a set of linked records. Attributes you do not mention are untouched. Use Attio: Update Record to add without removing.

Attio: Replace Entry Attribute History

attio_write_entry_attribute_values

DESTRUCTIVE AND IRREVERSIBLE. Replace a list entry attribute's ENTIRE value history. Every value it currently holds is destroyed, including values not in your request, and Attio requires replace_history true as an acknowledgement. It exists for migrating stage history in from another CRM, not for moving an entry between stages, which belongs on Attio: Update List Entry. These writes fire NO webhooks and NO workflow triggers, and history cannot be written for relationship or formula attributes.

Attio: Replace Record Attribute History

attio_write_record_attribute_values

DESTRUCTIVE AND IRREVERSIBLE. Replace an attribute's ENTIRE value history on one record. Every value the attribute holds today is destroyed, including values not present in your request, and only what you send survives. Attio requires replace_history true as an explicit acknowledgement of that. It exists for migrating history in from another system, not for ordinary edits, which belong on Attio: Update Record. Note also that these writes fire NO webhooks and NO workflow triggers, so a migration does not replay automations, and that history cannot be written for relationship or formula attributes.

Attio: Update Attribute

attio_update_attribute

Rename an attribute, change its constraints or default, or ARCHIVE it by setting is_archived true. Archiving is Attio's answer to deletion here: the attribute and its data are hidden rather than destroyed, and setting is_archived back to false restores them. The attribute's type cannot be changed. Fields left blank are not touched.

Attio: Update List

attio_update_list

Rename a list or change who can see it. The parent object cannot be changed through the API at all: Attio deliberately restricts that to the UI because of the side effects. The same someone-must-have-full-access rule as creation applies, and sending workspace_member_access REPLACES the whole access list rather than adding to it.

Attio: Update List Entry

attio_update_entry

Update a list entry, APPENDING to multiselect attributes: values you send are prepended to what is already there and nothing is removed. Attributes you do not mention are untouched. This is the node for moving an entry to a new stage. Use Attio: Overwrite List Entry Values when the supplied list should become the whole list.

Attio: Update Object

attio_update_object

Rename an object or change its api_slug. Changing the slug breaks anything that referenced the object by its old slug, which is exactly why Attio recommends storing the object_id when an integration has to survive renames. Fields left blank are not changed.

Attio: Update Record

attio_update_record

Update a record, APPENDING to multiselect attributes. Values sent for a multiselect attribute are added in front of the ones already there; nothing is removed. Attributes you do not mention are untouched. Use Attio: Overwrite Record when you need the supplied list to be the whole list.

Attio: Update Select Option

attio_update_select_option

Rename a select option or archive it. Archiving hides the option from new selections without removing it from records that already carry it, and it is reversible. Renaming changes the title everywhere at once.

Attio: Update Status

attio_update_status

Rename a status, change its target time or celebration setting, or archive it. Archiving removes the stage from new selections without touching records that already sit in it, and is reversible.

Attio: Update Task

attio_update_task

Change a task's deadline, completion state, links or assignees. The task's CONTENT cannot be edited through the API, which is Attio's limitation rather than this node's. Sending linked_records or assignees REPLACES that list wholesale, so read the task first if you mean to add rather than replace.

Attio: Update Webhook

attio_update_webhook

Change a webhook's target URL or its subscriptions. Sending subscriptions REPLACES the whole set, so anything omitted stops being delivered. Changing the target URL re-checks the existing subscriptions against it, and a collision with another webhook is rejected with 409. The signing secret does not change and is not returned.

Attio: Upsert List Entry

attio_upsert_entry

Add a record to a list, or update its existing entry if it is already on there. This is the idempotent way to put something into a pipeline. Two things to know: multiselect attributes are made to match the values you send exactly, so anything omitted is removed, and if the record already has SEVERAL entries on this list Attio cannot choose between them and returns MULTIPLE_MATCH_RESULTS.

Attio: Upsert Record

attio_upsert_record

Create a record, or update the existing one that matches. Attio looks for a record whose matching attribute holds the same value; if it finds one it updates it, otherwise it creates. This is the node for ingesting leads, form submissions and webhook payloads, because it is the one that does not duplicate on a retry. One subtlety worth knowing: if the MATCHING attribute is multiselect, supplied values are added and nothing is removed, but every OTHER multiselect attribute is made to match the supplied list exactly, which deletes values you did not send.

Using the integration

On the automation canvas

Attio nodes chain with every other node. A form submission can become a company and a person with Attio: Upsert Record, a scheduled sweep can read Attio: List Tasks into a Mattering database and open a reminder when something is overdue, and Attio: Create Note can write a summarisation step's output straight onto the record it is about. Two values do most of the wiring: the object, chosen from Attio: List Objects, which scopes every attribute and record node, and the list, chosen from Attio: List All Lists, which scopes every entry node.

From AI assistants over MCP

Every node speaks MCP, the open protocol for connecting AI assistants to tools, so Claude, ChatGPT, and Matter, the assistant built into the platform, can drive the same surface. An agent can find a company with Attio: Search Records, read what is already known with Attio: Get Record, write a brief with Attio: Create Note, put it into a pipeline with Attio: Upsert List Entry and open a follow up with Attio: Create Task. The reads plus the create and upsert nodes are the comfortable surface to hand an agent; keep the 11 destructive nodes behind conditions or approval steps. Attio ships an MCP server of its own, listed across its plans, and it is worth knowing which is which before you choose: if what you want is an assistant that can reach Attio during a conversation, Attio's own server is a direct route with nothing in between. This integration is the operations side of the same platform: the same 76 nodes are canvas steps as well as MCP tools, so they run on a schedule or from a trigger with nobody present, chain with every other connector in one workflow, and hold the credential once in a shared workspace rather than in each person's local client config.

A CRM with no fixed schema, and how the pickers cope

Attio ships a people object and a companies object, and your workspace can add its own, rename them, and hang new attributes off any of them. So the identifiers this integration needs cannot be baked in, and the nodes discover them instead through four dependent chains. Object to attribute: Attio: List Objects fills the Object field, and the chosen object scopes Attio: List Attributes so the Attribute picker offers only attributes that exist on it, grouped by type. Object to attribute to option: choosing an attribute narrows the Attio: List Select Options and Attio: List Statuses pickers below it. List to entry: Attio: List All Lists fills the List field and scopes Attio: List Entries. Object to record: record ids come from Attio: Search Records. One consequence to design around: Attio's system object and attribute slugs are stable, but NON system slugs change when somebody renames the thing in the UI, and Attio's own guidance is to store ids in an integration that must survive that. Every endpoint accepts either form, so a long lived automation against a custom object can use the id instead of the slug.

Creating records without creating duplicates

Attio: Create Record ALWAYS creates: it throws on a conflict with a unique attribute rather than updating, which is right when a duplicate should be an error and wrong for any ingest path that could see the same person twice. Attio: Upsert Record is the node for that case: it looks for a record whose matching attribute holds the same value, updates it if it finds one, and creates it otherwise, which makes a retried workflow idempotent. One asymmetry inside upsert is worth reading twice, because it is where data goes missing: for the MATCHING attribute, supplied multiselect values are added and nothing is deleted, but for every OTHER multiselect attribute the supplied list becomes the entire list, so a value you omit is removed. Attio: Upsert List Entry does the same job on a list, with one documented failure mode of its own: it reports multiple match results when the record already has several entries on that list, which is reachable in normal use because Attio: Add Record To List deliberately allows duplicate entries for one record.

Update or overwrite: the difference is data loss

Attio exposes two verbs on records and entries and the difference is not a style choice, which is why they are separate nodes here rather than one node with a flag. Attio: Update Record and Attio: Update List Entry APPEND to multiselect attributes: values you send are added in front of the ones already there and nothing is removed. Attio: Overwrite Record Values and Attio: Overwrite List Entry Values REPLACE them: for every multiselect attribute you mention, the supplied list becomes the entire list and anything not in it is removed. Attributes you do not mention are untouched by either. The same replace behaviour shows up on a few specific fields elsewhere, and each one says so: linked records and assignees on Attio: Update Task replace rather than add, subscriptions on Attio: Update Webhook replace the whole set, and member access on Attio: Update List replaces the whole list of entries.

Lists, entries, and where a pipeline actually lives

A list in Attio is a pipeline or a working set, and a record's position in it is an ENTRY that carries its own attributes: stage, owner, value, whatever that list defines. That is why Attio: List Entries and Attio: Get List Entry matter as much as the record nodes. Attio: List Record Entries runs the other way and answers which pipelines a record is currently in, across every list. Attio: List Statuses reads the stage vocabulary before a workflow writes a stage, which is worth doing because Attio matches on the option title. Attio: List List Views and Attio: List Object Views return the saved views people built in the UI, and feeding a view id to the entry or record lister reproduces exactly the filtered board somebody is looking at. Two constraints from Attio itself: a list's parent object cannot be changed through the API at all, and Attio: Create List and Attio: Update List are rejected unless someone has full access, either at workspace level or through at least one member entry.

Value history, and the two nodes that destroy it

Attio stores a history of values rather than only the current one, with each value carrying the window it was active for. Attio: List Record Attribute Values and Attio: List Entry Attribute Values read one attribute's values on a record or an entry, optionally including every historic value oldest first, which is how you reconstruct a deal's stage history or answer when an owner changed without an audit product. Their write siblings, Attio: Replace Record Attribute History and Attio: Replace Entry Attribute History, are the two sharpest nodes in this integration: they destroy the attribute's ENTIRE value history on that record or entry, including values not present in your request, and Attio requires an explicit acknowledgement flag before it will do it. Two more things to know before wiring them into anything. They fire NO webhooks and NO workflow triggers, which is deliberate on Attio's side so that a migration does not replay automations, but it means a chain expecting a downstream trigger will silently not fire. And asking for history on communication intelligence or enriched attributes is rejected outright.

Notes, tasks and comments, including the one that notifies

Attio: Create Note writes onto a record and accepts markdown, so headings and lists survive: it is the natural landing place for an AI generated call summary or research brief. Attio: Create Task creates a follow up, assigns it and links it to records, and its linked records field is unusually forgiving, accepting a record id, a company domain or a person's email address. Two Attio limits on tasks worth knowing: a task's CONTENT cannot be edited after creation, so Attio: Update Task only changes the deadline, completion state, links and assignees, and task content is plaintext only with no rich text, links or mentions. Attio: Create Comment needs exactly one of a thread id, a record or an entry, and only workspace members can author comments. The behaviour that makes comments genuinely useful from a workflow is that putting a workspace member's email address in the comment content NOTIFIES that person, while any other address becomes an ordinary mailto link. That is the mechanism for pinging an owner, and it is also the reason not to paste arbitrary contact lists into a comment body.

Meetings, call recordings and files

Attio: Create Meeting records a meeting with its participants and linked records, which is how an external calendar or notetaker syncs its events in, and Attio: Create Call Recording attaches a recording with its transcript. Attio: Get Call Recording reads the transcript back as timed segments with speaker attribution plus a flat readable version, which makes a good input for a summarisation step that then writes a note onto the record. Four behaviours to plan around, all Attio's own. Participants given by EMAIL ADDRESS automatically create person and company records, while participants given by name only do not. There is no built in de duplication, so a re run creates a second meeting rather than updating the first. A meeting's end is EXCLUSIVE, so a meeting ending at three ends before three and an all day meeting on the twenty seventh has an end date of the twenty eighth. And Attio: List Meetings combines a participant filter and a linked record filter with OR rather than AND, so supplying both widens the results rather than narrowing them. On files, Attio: List Files reads what is attached to one record, both files stored in Attio and folders connected from an external provider, and Attio: Create Folder creates a native folder or connects an existing external one. Meetings, call recordings and files are all documented as beta.

Webhooks, and the secret you only see once

Attio: Create Webhook registers a webhook so Attio pushes record, list entry, note, task, comment and attribute events to a URL. The create response is the ONLY time the signing secret is returned: it is not echoed by Attio: Get Webhook or Attio: List Webhooks, so capture it in the same run that creates the webhook or recreate the webhook to get a new one. Attio: Update Webhook changes the target URL or the subscriptions, and sending subscriptions REPLACES the whole set, so anything omitted stops being delivered. Attio: Delete Webhook is destructive: it removes every subscription and destroys the signing secret with it, delivery stops immediately, and events during the gap are not replayed. One duplicate rule to know when a workflow re registers on a schedule: Attio rejects a webhook whose target URL, event type and filter match an existing one.

The 11 destructive nodes, gated

Attio's archiving guide is unambiguous: deleted data is eventually removed from Attio's servers entirely with no ability to restore it. There is no trash and no restore window, so the guardrails have to be structural. Attio: Delete Record takes the record, every attribute value AND its history, and its entries in every list. Attio: Merge Records destroys the SECONDARY record, keeping its values only where the primary had none, with no unmerge. Attio: Replace Record Attribute History and Attio: Replace Entry Attribute History destroy a whole value history. Attio: Delete List Entry takes the entry and every list specific value and history on it, the stage reached and when, while the underlying record survives. Attio: Delete Note, Attio: Delete Task and Attio: Delete Call Recording take their subject and, for the recording, the transcript and every summary derived from it. Attio: Delete Comment has the least obvious blast radius: deleting the FIRST comment in a thread deletes every other comment in that thread, including replies by other people. Attio: Delete File deletes every descendant when the target is a folder. Attio: Delete Webhook is covered above. Where Attio offers a reversible alternative it is usually the right one: nothing in the attributes family is destructive because Attio ships no delete for attributes, select options or statuses at all, so Attio: Update Attribute, Attio: Update Select Option and Attio: Update Status archive instead, which is reversible. To mark work finished, set the completion flag with Attio: Update Task rather than deleting the task. To take something out of a pipeline, delete the list ENTRY rather than the record.

Troubleshooting

Test Connection succeeds but every node fails afterwards
Check the active flag rather than the status code. This is the one Attio specific thing that differs from most integrations: a revoked or malformed token can answer HTTP 200 with an active flag set to false, so a 200 alone is not proof the token works. Run Attio: Identify Token on the canvas and read the response: if the active flag is false, the token has been revoked or is malformed and needs replacing in Attio's developer settings, whatever the status code says. If it is true, read the scope string in the same response, because the connection probe is the only operation in Attio's specification that requires no scopes, which means a token too narrow for real work still passes the connection test.
One family of nodes returns a permissions error while the rest work
That is a scope miss rather than a broken credential. Attio declares required scopes per endpoint family: object configuration, record permission, list configuration, list entry, user management, note, task, comment, email, meeting, call recording, file and webhook, each read only or read and write. A token created with a narrow set works everywhere it was granted and is refused everywhere it was not. Run Attio: Identify Token to see the scope string the token carries, then edit the token's scopes in Attio's developer settings, which Attio allows after creation, rather than issuing a new one. Note the pattern that catches people: object configuration is a secondary scope on nearly everything, so leaving it off breaks far more than object nodes.
List Emails or Query SQL fails on a token that works everywhere else
Neither is a wiring problem, and they fail for different reasons. Attio: Query SQL states in Attio's own specification that the workspace must be on the Enterprise plan, so on any other plan it is refused regardless of scopes. Attio: List Emails is documented as alpha and enabled per workspace and per app on request to Attio's support team, so access has to be granted before it will answer. Two more things about the email lister once you do have access: it refuses to list everything, requiring at least one of linked records, participants or a domain, and it ignores filters that identify your own workspace, so filtering by a colleague's address returns nothing rather than their mail.
A template reading a record's name resolves to nothing
A record's values are a MAP keyed by attribute slug, each mapping to an ARRAY of value objects, not a flat row and not a list you can fan out over. So a path with a wildcard across values will never resolve: a person's full name and a company's name sit at different paths through that map, and which keys exist at all is workspace defined, which is why Attio: List Attributes matters as much as it does. Run it against the object first to see the actual slugs, then write the path through the map. The same is true of a list entry's values. If what you need is a display name for a picker or a report, Attio: Search Records returns it directly, and Attio: Query SQL returns genuinely flat rows on an Enterprise workspace.
A record created seconds ago is not found by search
That is documented rather than broken. Attio: Search Records is beta and eventually consistent, so a record written a moment ago may not be indexed yet, and this is exactly the case where a workflow that writes then immediately searches looks flaky. Use Attio: List Records when a workflow has just written something and must read it back, because the record query is strongly consistent. Reserve search for finding things a human or an agent knows the name of rather than for confirming a write. The same consideration applies to any picker in this integration that reads from search: it will catch up, it just may not have yet.
Create Record fails with a conflict on a unique attribute
That is Attio: Create Record behaving as designed: it always creates and throws on a unique conflict rather than updating. Any ingest path that could see the same person or company twice wants Attio: Upsert Record instead, which matches on an attribute you nominate and updates when it finds a match. When you switch, read the multiselect asymmetry before you rely on it: for the MATCHING attribute supplied values are added and nothing is removed, but for every other multiselect attribute the supplied list becomes the entire list, so a value you leave out is removed from the record.
A multiselect attribute lost values after an update
The wrong verb was used. Attio: Overwrite Record Values and Attio: Overwrite List Entry Values REPLACE multiselect attributes: for every one you mention, the supplied list becomes the entire list and anything not in it is removed. Attio: Update Record and Attio: Update List Entry APPEND instead, adding what you send and removing nothing. Attributes you do not mention are untouched by either, so the fix is usually to switch nodes rather than to change the payload. The same replacement behaviour bites on a few named fields elsewhere: linked records and assignees on Attio: Update Task, subscriptions on Attio: Update Webhook and member access on Attio: Update List all replace the whole set rather than adding to it.
A downstream workflow never fired after an attribute history write
It will not. Attio deliberately fires NO webhooks and NO workflow triggers for Attio: Replace Record Attribute History and Attio: Replace Entry Attribute History, so that a data migration does not replay every automation in the workspace. That is correct behaviour on Attio's side and a real trap on ours, because a chain that expects a webhook to carry the next step will simply stop. Wire the next step directly onto the history write in the same workflow rather than relying on an event coming back around.
The webhook signing secret is missing
It is returned exactly once, in the response to Attio: Create Webhook, and nowhere else: neither Attio: Get Webhook nor Attio: List Webhooks echoes it. If it was not captured in the same run that created the webhook, the only route to a secret is to create the webhook again, which means distributing a new one. Two related behaviours: Attio: Update Webhook replaces the whole subscription set when subscriptions are sent, so anything omitted stops being delivered, and Attio rejects a create whose target URL, event type and filter duplicate an existing webhook, which is what a re registering scheduled workflow will hit.
Deleting one comment removed a whole conversation
That is the documented blast radius rather than a fault. Attio: Delete Comment removes only itself when the target is a reply, but when the target is the FIRST comment in a thread, Attio deletes every other comment in that thread, including replies written by other people. There is no undo: Attio's archiving guide states that deleted data is eventually removed entirely with no ability to restore it. Read Attio: Get Thread before deleting anything to see whether the comment in hand is the first one, and gate comment deletion behind an approval step rather than a bare trigger.
Calls start failing with 429
Attio documents 100 read requests per second and 25 write requests per second, and a rejected request returns HTTP 429 with a retry hint. A rejected request was not executed, so it is safe to retry, usually on the next second. Two specifics cause most real 429s here. Creating a call recording is capped at ONE request per second, far below the general write limit, so a backfill of historical calls has to be throttled deliberately. And Attio: List Records and Attio: List Entries additionally score query complexity: a single over complex query is rejected and must be simplified, and the cumulative score across a short sliding window can trip the limit even when the request rate looks modest, which is worth knowing before pointing a dashboard at a heavily filtered list query on a fast refresh.

Attio is a trademark of its respective owner. Mattering uses platform names to identify the services these integrations connect to; no endorsement or affiliation is implied.

Start Free Explore our Products