Menu
Mattering Automations connector

A Coda MCP for work that runs when nobody is watching

65 nodes on the Coda API: docs and folders, pages and page content, tables, columns, rows, formulas, controls, permissions and sharing policy, publishing and custom domains, workspace members and roles, and analytics. 38 read and 27 act. Coda accepts most writes rather than completing them, answering HTTP 202 with a request id, and every node here is built around that instead of pretending it does not happen.

65 ready-made nodes One credential to connect Works with Claude, ChatGPT, and Matter

What the Coda MCP connector does

The Coda connector for Mattering Automations is 65 nodes built from Coda's own published API description, version 1.6.0 of the v1 API. Docs, folders and workspaces cover where things live. Pages, page content and page exports cover the writing. Tables, columns, rows, formulas and controls cover the data and the logic a team already built inside a doc. Permissions, sharing settings, publishing and custom domains cover who can see it. Workspace members, role changes and role activity cover the seats. Analytics covers usage, including Pack revenue for anyone who publishes one. Thirty eight nodes read and twenty seven act.

One naming note before anything else, because it will confuse you otherwise. Coda is being rebranded as Superhuman Docs. The reference documentation now sits at docs.superhuman.com and titles itself the Superhuman Docs API, and the spec describes the product as Superhuman Docs, formerly Coda. The product and the API are the same thing they were: the API base this connector calls is still coda.io/apis/v1, the same tokens work, and the same endpoints answer. The connector is named Coda because that is what the product is still called in its own URLs and in everything anyone has already built. If you arrived here from a Superhuman page, you are in the right place.

Every capability is a node on the Automations canvas, and every node speaks MCP, the open protocol for connecting AI assistants to tools. Claude, ChatGPT, and any other MCP-capable assistant can work with Coda through your workspace, alongside Matter, the AI assistant built into the platform. The same nodes are steps in a visual workflow, so the thing an assistant helps you work out by hand can then run on a schedule with nobody present.

Coda runs an MCP server of its own, and it would be silly for a page about Coda MCP not to say so. Coda's API description links a guide to it, and the guide is clear about the job it does: you connect an AI client, paste a doc link, describe an outcome in a sentence, and an agent creates the doc, builds the table or rewrites the page for you. That is a good conversational surface and this page is not going to pretend otherwise. It is a different job from this one. These nodes are workflow steps rather than a chat surface, so they run on a schedule or off another system's event with nobody present, chain with every other connector in the same workflow, hold one credential in a shared workspace store rather than in each person's local client config, carry destructive flags on the ten nodes that need them, and expose Coda's queued writes as something a following step can actually verify. Use both if you like. They do not overlap much.

The behaviour to understand before you build anything is that Coda accepts most writes rather than performing them. Fourteen of the operations behind these nodes answer HTTP 202, which Coda's documentation states means the edit has been accepted and queued for processing, not applied, and Coda is explicit that the edit may still fail during processing if it turns out to be invalid. So a node that reports success can leave nothing in the doc, and a step that reads the record back immediately after a write frequently reads the old value. Every affected node here returns Coda's requestId as an output you can drag into the next step, attaches a marker to the response when Coda answers 202, and carries the warning in its own description. Coda: Get Mutation Status is the node that resolves it: pass the request id and it answers whether the edit completed, plus a warning field that is populated when a write succeeded but had to be corrected on the way in, such as invalid HTML in page content.

Three smaller design decisions are worth knowing because they change what your workflows get back. Coda lets most paths address a table, page, row, column, formula or control by name instead of by id, and warns that when several objects share a name an arbitrary one is selected, for writes and deletes as well as reads. Row names are just the display column's value, so they are rarely unique. Every such field here is fed by a picker that stores the id, and the row picker carries the row id on its second line so two rows labelled the same stay distinguishable. Separately, Coda's default value format flattens multi value cells into a comma delimited string, which makes a value containing a comma indistinguishable from two values, so the row nodes here default to simpleWithArrays and say plainly that this differs from Coda's own default. And Coda: List Rows accepts a sync token, so a scheduled workflow can pass back the token from its last run and receive only what changed rather than re-reading a large table.

On plans, the good news is unusually clean. Coda states in its API reference, under a heading written for this exact question, that the API is available to all of its users free of charge in both free and paid workspaces, and that usage is instead governed by the role of the token's owner. Two roles matter: creating a doc requires the token owner to be a Doc Maker or Admin, with an Editor auto promoted when the workspace allows any member to create docs, and changing someone's workspace role requires Admin. One node is genuinely plan gated, and it hides it badly. Coda: List Page Analytics is documented as returning HTTP 401 when the doc is not in an Enterprise workspace, so on any other plan it looks exactly like a broken credential while every other node works with the same token. Nothing else in this connector is plan gated.

What is deliberately not here is the Pack build and publish surface. Coda documents 124 operations and 60 of them concern Packs, of which 59 are the Pack build and publish lifecycle: source and asset uploads through multi step signed handshakes, version registration, release management, OAuth and system connection configuration, maker administration and ingestion logs. That is developer tooling driven by Coda's own command line tool against a local Pack project, not workflow automation, and one of those operations exists specifically to store third party credentials inside Coda, which is not a capability an automation connector should hold. All 59 are excluded. The remaining one, Coda: List Packs, ships read only for one concrete reason: three analytics nodes take a Pack id, and without a lister that field would be a text box asking for a number you have no way to find. There are also no trigger nodes here, because this API offers no subscription surface to build them from, so Coda workflows run on a schedule or off another system's event.

One connection, three surfaces

  • Visual automations. Drag Coda nodes onto the canvas and wire them to triggers, conditions, and other apps.
  • AI agents, yours or ours. These nodes speak MCP, the open protocol, so Claude, ChatGPT, and any MCP-capable assistant can use them, and Matter, the agent built into the platform, uses them natively.
  • The whole platform. Combine with native tasks, projects, and other connectors, no middleware in between.

Every Coda node, ready to drop on the canvas

65 nodes, generated from the connector itself so this list always matches what ships. Expand a category to browse.

Read and query nodes 38

Coda: Get Analytics Last Updated

Return the most recent day each analytics dataset covers, separately for doc analytics, Pack analytics and Pack formula analytics, in Pacific Standard Time. Run this FIRST in any scheduled analytics job. Coda's analytics lag real time by an unpublished and variable amount, so a report that assumes yesterday is available will silently produce a window with a missing tail. This node is how a workflow discovers where the data actually ends instead of assuming. It needs no parameters and it is the only endpoint in this connector that does not document a 401.

Coda: Get Column

Fetch one column in detail: name, whether it is the display column, whether it is calculated, its formula, its default value and its full format block. The format block is what makes this worth a call of its own, because it tells you what a value written into this column has to look like, including whether the column holds an array, and for a button column it carries the button's label, its disable condition and the action it performs.

Coda: Get Control

Read one control's type and current value, for example the position of a slider or the selection in a dropdown. Handy for letting a person set a threshold or pick an option inside the doc and having an automation read that choice on its next run, which is a lightweight settings surface with no extra interface to build. Controls cannot be SET through this API.

Coda: Get Current User

Return the account behind the API token: display name, login email, the workspace the token belongs to, the token's own name, and whether the token is scoped. This is the cheapest authenticated call on the whole API, takes no parameters at all, and is the right first node when checking that a Coda connection works. It is also how you find a workspace ID without opening the browser. Note that it returns the token OWNER, so everything this connector does elsewhere runs with that person's permissions.

Coda: Get Custom Domain Provider

Identify which registrar or DNS provider a domain uses, for example GoDaddy. Coda uses this to tailor its own setup instructions, and an automation can use it the same way, to send whoever is doing the DNS work the right walkthrough for their provider instead of a generic one. Takes a bare domain and needs no doc.

Coda: Get Doc

Fetch one doc's metadata: name, owner, icon, folder, workspace, created and updated timestamps, publishing state and size. The size block is the useful part and is easy to miss. It carries totalRowCount, tableAndViewCount, pageCount and an overApiSizeLimit flag, which is Coda telling you the doc is too large for some API operations before you discover it by failing.

Coda: Get Doc Analytics Summary

One number for a whole period: total sessions across the docs matching the filters. There is no per day breakdown here and no per doc breakdown either, which is the point. Use it for a headline figure or a period over period comparison, and use Coda: List Doc Analytics when you need the shape of the traffic rather than its size.

Coda: Get Folder

Fetch one folder: name, description, icon, browser link, creation time, its workspace, and a canEdit flag saying whether this token's owner may change it. Checking canEdit before attempting a rename turns a 403 mid workflow into a clean decision.

Coda: Get Formula

Read the current VALUE of a named formula. This is how an automation pulls one already computed number out of a Coda doc, a total or a count or a status, without fetching the rows behind it and recomputing anything. Remember what the API cannot see: a formula built on Today(), Now() or User() returns a value only as current as the doc's last edit, and user based values may be blank, because there is no interactive user on an API call.

Coda: Get Mutation Status

Ask whether an earlier write has actually been applied. This is the companion to every asynchronous node in this connector, and the reason they are usable at all. Coda answers writes with HTTP 202 meaning queued, not done, and returns a requestId; pass that requestId here and the response says completed true or false. Read the warning field too: it is populated on writes that SUCCEEDED but had to be corrected along the way, such as invalid HTML in page content, which is a signal worth surfacing rather than discarding. Two limits to design around. Coda does not guarantee status is available more than one day after the mutation completed, so this is a shortly after check and not an audit trail. And completed false simply means not yet, so check it again after a short wait rather than in a tight loop.

Coda: Get Pack Analytics Summary

Three headline numbers for a period across the Packs this token's owner can edit: total doc installs, total workspace installs and total invocations. No per day and no per Pack breakdown. Good for a weekly status line; use Coda: List Pack Analytics when the trend or the per Pack split matters.

Coda: Get Page

Fetch one page's metadata: name, subtitle, icon, cover image, content type, hidden flags, parent, children, authors and who last changed it. This returns the data ABOUT the page, not the text on it. Use Coda: List Page Content for the text, or Coda: Begin Page Content Export for a whole page as Markdown or HTML. A page that has been deleted answers HTTP 410 rather than 404, which is a useful distinction: 410 means it existed.

Coda: Get Page Content Export Status

Check an export started by Coda: Begin Page Content Export and collect the file when it is ready. Status moves through inProgress to complete or failed; on complete the response carries a downloadLink, and on failed it carries an error string saying why. The download link is a short lived signed URL that grants access to the page's contents to anyone holding it, so treat it as sensitive and fetch it promptly with an HTTP node rather than storing it. Poll this node with a wait between attempts rather than in a tight loop.

Coda: Get Row

Fetch a single row with all of its cell values, plus the table it belongs to. Value format works exactly as it does on Coda: List Rows and matters just as much. If the row is addressed by NAME rather than by ID, Coda returns one arbitrary match rather than telling you the name was ambiguous, so prefer the ID, which the picker stores for you.

Coda: Get Sharing Metadata

Ask what this token is ALLOWED to do about sharing a doc, before trying it: whether it can share at all, whether it can share with the whole workspace, whether it can share with the whole organization, and whether the doc may be copied. Run this ahead of Coda: Add Permission and a workflow can fail politely with a clear message instead of collecting a 403 halfway through.

Coda: Get Sharing Settings

Read a doc's sharing POLICY, which is a different thing from its list of shares: whether editors may change permissions themselves, whether viewers may copy the doc, and whether viewers may request edit access. Worth auditing on docs holding anything sensitive, because allowCopying true means any viewer can take a full copy of the data out of your governance entirely.

Coda: Get Table

Fetch one table or view in detail: row count, display column, sorts, layout, filter state, the page it lives on, and for a view the parent table it draws from. Two fields earn their keep. rowCount lets an automation size a job before starting it. The filter block's isVolatile, hasUserFormula, hasTodayFormula and hasNowFormula flags warn that the view's contents depend on who is looking or what time it is, which through the API means the answer may not match what a person sees in the browser.

Coda: List Columns

List a table's columns with their IDs, names, types and formulas. This is the node that makes writing to Coda reliable, because a write addresses cells by column ID and this is where those IDs come from. Two flags decide whether a column can be written at all: calculated true means the value is computed by a formula and cannot be set, and format.type says what shape a value has to take. display true marks the column whose values act as row names.

Coda: List Controls

List a doc's controls: the sliders, selects, date pickers, checkboxes and buttons that people use to drive the doc from the inside. Controls are read only through this API, so this is for reading the settings a team has chosen rather than for changing them. Their current values often drive the filters on the views you are about to read, which makes this a useful companion call when a table's contents look unexpected.

Coda: List Custom Doc Domains

List the custom domains serving a published doc, with each one's certificate state, DNS state, setup status and the time it was last verified. This is the node to poll after adding a domain, since a custom domain is not live the moment it is added: DNS has to resolve and a certificate has to be issued first. Note that the results come back under customDocDomains, not under the items key the rest of this API uses for lists.

Coda: List Doc Analytics

Per day usage numbers for the docs this token can see: views, copies, likes, sessions split by desktop, mobile and other, and AI credit consumption broken out by where it was spent, across chat, blocks, columns, the assistant and the reviewer. The AI credit columns are the ones worth watching, because they are the metered part of a Coda subscription. Note the response shape before charting it: each item is a DOC, and that doc's daily numbers are a metrics array nested inside it, rather than one flat row per day. Analytics lag real time; Coda: Get Analytics Last Updated says by how much.

Coda: List Doc Categories

List the categories a published doc can be filed under, for example Project Management. Takes no parameters and is the same for everyone, so it is really a lookup table. Its one job is supplying valid values for the category names on Coda: Publish Doc, which rejects a name it does not recognise.

Coda: List Docs

List the Coda docs this token can reach, with each doc's owner, folder, workspace, size, timestamps and publishing state. This is the source for every doc picker in this connector and the natural first node in most Coda workflows. One thing to know before relying on it as an inventory: Coda returns docs the user has OPENED AT LEAST ONCE, in the same order as the docs page, so a doc shared with them but never visited will not appear.

Coda: List Folders

List the folders this token can reach, each with its name, description, whether the token's owner can edit it, and the full workspace it belongs to. Two jobs beyond the obvious one: it is the source for the folder picker used when creating docs, and because every folder carries its whole workspace object, it is also how this connector offers a workspace picker at all. Coda ships no workspace lister of its own.

Coda: List Formulas

List the NAMED formulas in a doc, with the page each one lives on. Only named formulas appear here; the formulas inside table columns are part of those columns and show up through Coda: List Columns instead. A named formula is a value the doc's own authors chose to compute and label, which makes this list a good map of the numbers a team already cares about.

Coda: List Pack Analytics

Per day numbers for the Coda Packs this token's owner can edit: doc and workspace installs, invocation counts split by formula, action, sync and metadata, actively using doc and workspace counts over several trailing windows, trial and subscription counts, and revenue in US dollars. If you publish a Pack, this is your product dashboard, and it is the only place revenue and subscription figures are exposed through the API. Same nesting as the doc analytics: each item is a PACK with its daily numbers in a metrics array inside it.

Coda: List Pack Formula Analytics

Per formula, per day performance for one Pack: invocation counts, error counts, median latency in milliseconds, median response size, and the actively using doc and workspace families. This is where a Pack maker finds the formula that is slow or failing rather than just the Pack that is. Treat the median columns carefully in any rollup: medians cannot be recombined across days into a period median.

Coda: List Packs

List the Coda Packs this token's owner can reach, with each Pack's numeric ID, name, descriptions, categories, workspace and certification state. Packs are Coda's extensions, and this is the only Pack node in this connector: it ships so that the three analytics nodes taking a Pack ID have somewhere to get one. Building, versioning and publishing a Pack is done with Coda's own command line tool rather than through automation nodes.

Coda: List Page Analytics

Per page, per day analytics inside one doc: views, sessions, unique users, average and median seconds viewed, and tab counts. This is the node that answers which parts of a long internal doc people actually read. ENTERPRISE ONLY, and the failure is misleading: Coda's own documentation says this endpoint returns HTTP 401 when the doc is not in an Enterprise workspace. A 401 normally means a bad token, so on a non Enterprise workspace this node looks like a broken credential rather than a plan limit. Every other node in this connector works on any plan, free included.

Coda: List Page Content

Read the actual content of a page, element by element. Each item carries its own element ID, its type, and an itemContent block with the text, its style such as blockQuote or heading, and its indent level. The element IDs are the reason to use this node rather than the export: they are what Coda: Update Page and Coda: Delete Page Content need in order to edit or remove ONE element instead of the whole page. For reading a page as a single document, the export node is better.

Coda: List Pages

List the pages in a doc, with each page's name, subtitle, content type, hidden state, parent, children, authors and timestamps. The parent and children fields make the page tree walkable, and the two hidden flags are not the same thing: isHidden is the page's own setting while isEffectivelyHidden is true when any ancestor is hidden. This node is the source for every page picker in this connector.

Coda: List Permissions

List everyone and everything a doc is shared with, and at what level. Each entry carries a permission ID, an access level of readonly, write or comment, and a principal. The principal is one of five kinds and this is where the surprises live: as well as an individual email or a group, a doc can be shared with an entire DOMAIN, an entire WORKSPACE, or with ANYONE holding the link. This node is the way to audit that from an automation. It is also the source of the permission IDs that Coda: Delete Permission needs.

Coda: List Rows

Read rows out of a Coda table or view. Each row carries its ID, its name (the display column's value), its index, its timestamps and a values object keyed by column ID. Set value format deliberately, because Coda's default is lossy: it flattens multi value cells into a comma delimited STRING, so a value that itself contains a comma becomes indistinguishable from two values. simpleWithArrays is usually what an automation wants. This node also supports incremental reads through sync tokens: pass the nextSyncToken from a previous call and Coda returns only what has changed since. That is the efficient way to poll a large table on a schedule.

Coda: List Tables

List the tables and views in a doc, with each one's name, type and the page it sits on. Read tableType before doing anything with the result: a base TABLE holds the data, a VIEW is a filtered window onto another table, and rows cannot be inserted into a view. That single distinction is behind most confusing failures on this API, which is why the table picker in this connector groups its options by it. This node is the source for every table picker here.

Coda: List Workspace Members

List the people in a workspace with their role, when they registered, when their role last changed, when they were last active, and how many docs they own and collaborate on. Coda returns the requesting user first and then orders by role. The activity columns make this a genuine licence audit source: docsLastActiveAt and lastActiveAt together identify Doc Makers who have not touched anything in months, which is the seat you are paying for and nobody is using.

Coda: List Workspace Role Activity

Return a workspace's headcount by role over time, one row per month, split into active and inactive counts for Admins, Doc Makers and Editors. This is the seat trend an administrator wants when deciding whether a plan still fits: growing inactive Doc Maker counts month on month are seats being paid for and not used. It takes no date range, returning whatever history Coda holds.

Coda: Resolve Browser Link

Turn a Coda URL that someone pasted into the IDs an API can use. Give it any browser link to a doc, page, table or row and it returns the resource's type, its ID and an API href. This is the friendliest possible front door for a workflow driven by humans: a person drops a link into a form or a chat message and the automation resolves it rather than asking anyone to hunt for a doc ID. Coda answers 400 for a URL that is not a Coda URL, and 404 when the resource exists but this token cannot see it, which are usefully different failures.

Coda: Search Principals

Find the users and groups a given doc can be shared with, by search term. This is the lookup step before Coda: Add Permission, and it is the only way to obtain a group ID. Two limits to design around: Coda returns at most 20 users and 20 groups, and an EMPTY query returns nothing at all rather than everything, so this cannot be used to enumerate a directory.

Action nodes 27

Coda: Add Custom Doc Domain

Point a domain you own at a published Coda doc, so it serves from your own address instead of a coda.io URL. The doc has to be published first. Adding the domain here is only half the job: DNS records still have to point at Coda and a certificate still has to be issued, so poll Coda: List Custom Doc Domains until setupStatus and domainStatus say the domain is connected. This write is ASYNCHRONOUS. Coda answers HTTP 202 meaning accepted and queued, not applied. The change usually lands within a few seconds and it can still FAIL after the 202, because Coda validates the values while processing rather than while responding. Take requestId from this node's output and pass it to Coda: Get Mutation Status before any step that depends on the change having happened, and do not read the record back immediately and expect the new value.

Coda: Add Go Link

Create an organization go link, one of the short go/name redirects a company uses internally. Automating these keeps a link directory in step with something else: a new project gets go/project-name pointing at its dashboard the moment the project is created. The URL pattern field supports variables, so one link can serve a family of destinations. Note that this API creates go links and offers no endpoint to list, update or delete them, so an automation that creates them should keep its own record of what it made.

Coda: Add Permission

Share a doc with a person, a group, a domain, a workspace or with anyone holding the link. Useful for onboarding automations that grant a new hire access to the right docs on day one. Take the last two principal types seriously: domain shares every account on an email domain, and anyone makes the doc reachable by link with no sign in at all. Check what this token may do with Coda: Get Sharing Metadata first, since some of these are blocked by workspace policy. Suppress email is worth setting for bulk grants so a hundred people do not each get a notification.

Coda: Begin Page Content Export

Start an export of a whole page as HTML or Markdown. This is the node to use when a workflow needs a page as a DOCUMENT rather than as a list of elements, for example to feed a page of meeting notes into a summarizer. It starts the job and returns a request ID and a status link; the file itself arrives through Coda: Get Page Content Export Status, which returns a download link once the status reads complete. It is grouped as an action rather than a query because it queues work, but it changes nothing in the doc.

Coda: Change Workspace User Role

Change someone's role in a workspace. This is the node behind automated onboarding and licence reclamation: promote a new hire to Doc Maker on their start date, or demote a Doc Maker who has been inactive for ninety days back to Editor. The roles are Admin, DocMaker and Editor, and only Doc Makers and Admins can create docs, so a demotion is what actually frees a paid seat. Requires the API token's owner to hold ADMIN permissions in the workspace; anything less is refused.

Coda: Create Doc

Create a new Coda doc, either empty or as a copy of an existing one. Copying is the interesting half: point source doc at a template and every table, formula and automation in it comes with the copy, which turns a Coda doc into a repeatable per client or per project workspace an automation can spin up on demand. The response carries the new doc's ID and browser link. Unlike most writes on this API this one answers 201 with the finished doc rather than 202, although the initial page's content is still filled in afterwards. Requires the API token's owner to be a Doc Maker or an Admin in the workspace. An Editor is promoted automatically if the workspace has the option allowing any member to create docs. A token owned by a plain Editor in a workspace without that option gets HTTP 403.

Coda: Create Folder

Create a folder in a workspace. Pair it with Coda: Create Doc to stand up a whole per client or per project area in one run: make the folder, then copy a template doc into it. Answers 201 with the finished folder rather than 202, so the new folder ID is available immediately for the next node.

Coda: Create Page

Add a page to a doc, optionally as a subpage and optionally with content already on it. Three kinds of content are possible: authored canvas content written as Markdown or HTML, a full page embed of an external URL, and a copy of an existing page from this or another doc. Writing a run's output into a real Coda page, rather than into a row, is what this node is for. Requires the API token's owner to be a Doc Maker or an Admin in the workspace. An Editor is promoted automatically if the workspace has the option allowing any member to create docs. A token owned by a plain Editor in a workspace without that option gets HTTP 403. This write is ASYNCHRONOUS. Coda answers HTTP 202 meaning accepted and queued, not applied. The change usually lands within a few seconds and it can still FAIL after the 202, because Coda validates the values while processing rather than while responding. Take requestId from this node's output and pass it to Coda: Get Mutation Status before any step that depends on the change having happened, and do not read the record back immediately and expect the new value.

Coda: Delete Custom Doc Domain

Detach a custom domain from a published doc. The doc stays published and remains reachable at its coda.io URL, but every link anyone has to the custom address stops working immediately. The domain can be re-added later, and the DNS records on your side are not touched by this.

Coda: Delete Doc

Delete an entire Coda doc, with every page, table and row in it. This is the most destructive node in this connector by a wide margin: one doc can hold tens of thousands of rows and there is no per object confirmation. This deletion is permanent and Coda documents no way to undo it through the API. This write is ASYNCHRONOUS. Coda answers HTTP 202 meaning accepted and queued, not applied. The change usually lands within a few seconds and it can still FAIL after the 202, because Coda validates the values while processing rather than while responding. Take requestId from this node's output and pass it to Coda: Get Mutation Status before any step that depends on the change having happened, and do not read the record back immediately and expect the new value.

Coda: Delete Folder

Delete a folder. Coda protects you here in a way it does not elsewhere in this connector: the folder must be EMPTY, and a folder still containing docs is refused rather than deleted with its contents. So this cannot destroy documents, unlike Coda: Delete Doc and Coda: Delete Page. Clear the folder first if the deletion is genuinely intended.

Coda: Delete Multiple Rows

Delete several rows in one call, by ID. This takes IDs only, which is a mercy: unlike the single row delete there is no way to accidentally address a row by an ambiguous name. Feed it the IDs from a filtered Coda: List Rows to clear out everything matching a condition. This deletion is permanent and Coda documents no way to undo it through the API. This write is ASYNCHRONOUS. Coda answers HTTP 202 meaning accepted and queued, not applied. The change usually lands within a few seconds and it can still FAIL after the 202, because Coda validates the values while processing rather than while responding. Take requestId from this node's output and pass it to Coda: Get Mutation Status before any step that depends on the change having happened, and do not read the record back immediately and expect the new value.

Coda: Delete Page

Delete a page from a doc. Subpages go with it, and any table living on the page goes too, which is the surprise here: deleting a page can destroy data that looks like it belongs to the doc rather than to the page. This deletion is permanent and Coda documents no way to undo it through the API. This write is ASYNCHRONOUS. Coda answers HTTP 202 meaning accepted and queued, not applied. The change usually lands within a few seconds and it can still FAIL after the 202, because Coda validates the values while processing rather than while responding. Take requestId from this node's output and pass it to Coda: Get Mutation Status before any step that depends on the change having happened, and do not read the record back immediately and expect the new value.

Coda: Delete Page Content

Remove content from a page, either specific elements or all of it. Leaving the element list EMPTY deletes everything on the page, which is the opposite of how most delete endpoints behave and is worth reading twice before scheduling. Element IDs come from Coda: List Page Content. The page itself survives either way. This deletion is permanent and Coda documents no way to undo it through the API. This write is ASYNCHRONOUS. Coda answers HTTP 202 meaning accepted and queued, not applied. The change usually lands within a few seconds and it can still FAIL after the 202, because Coda validates the values while processing rather than while responding. Take requestId from this node's output and pass it to Coda: Get Mutation Status before any step that depends on the change having happened, and do not read the record back immediately and expect the new value.

Coda: Delete Permission

Revoke one share on a doc. This is the offboarding half of the permissions pair: read the current shares with Coda: List Permissions, find the one belonging to the person or group leaving, and remove it. Removing a domain, workspace or anyone permission cuts off many people at once, so check the principal on the entry before deleting it.

Coda: Delete Row

Delete one row from a table or view. Coda's own warning applies with full force here: when the row is addressed by NAME rather than by ID, an arbitrary matching row is removed. Because row names are just display column values, that is a realistic way to delete the wrong record. Always use the ID. This deletion is permanent and Coda documents no way to undo it through the API. This write is ASYNCHRONOUS. Coda answers HTTP 202 meaning accepted and queued, not applied. The change usually lands within a few seconds and it can still FAIL after the 202, because Coda validates the values while processing rather than while responding. Take requestId from this node's output and pass it to Coda: Get Mutation Status before any step that depends on the change having happened, and do not read the record back immediately and expect the new value.

Coda: Insert or Upsert Rows

Add rows to a Coda table, or update existing ones in the same call. With no key columns this always inserts. Name one or more key columns and it becomes an upsert: Coda looks for rows whose key columns match and updates them instead of adding duplicates, which is what makes a repeating automation safe to run twice. Read Coda's own warning on that behaviour before relying on it: when SEVERAL rows match the key, ALL of them are updated, so a key that is not actually unique silently rewrites more rows than you meant. Works on base tables only, never on views. This write is ASYNCHRONOUS. Coda answers HTTP 202 meaning accepted and queued, not applied. The change usually lands within a few seconds and it can still FAIL after the 202, because Coda validates the values while processing rather than while responding. Take requestId from this node's output and pass it to Coda: Get Mutation Status before any step that depends on the change having happened, and do not read the record back immediately and expect the new value.

Coda: Publish Doc

Publish a doc to the public web, or change how an already published doc is published. Understand what this does before scheduling it: publishing makes the doc's contents readable by anyone who finds the URL, with no Coda account required. Discoverable additionally lists it in Coda's public gallery and to search engines. Mode decides how visitors can interact with it, where view is read only, play lets them use interactive elements without saving, and edit lets them change the published copy. Reversible with Coda: Unpublish Doc. This write is ASYNCHRONOUS. Coda answers HTTP 202 meaning accepted and queued, not applied. The change usually lands within a few seconds and it can still FAIL after the 202, because Coda validates the values while processing rather than while responding. Take requestId from this node's output and pass it to Coda: Get Mutation Status before any step that depends on the change having happened, and do not read the record back immediately and expect the new value.

Coda: Push Button

Press a button in a Coda table from an automation, running whatever that button does. This is the bridge between a Mattering workflow and logic a team already built inside their doc, and it is the most powerful node in this connector. Read Coda's own authorization note before using it: the API only checks that the token can WRITE TO THIS TABLE, but the button itself can perform any action anywhere in the document, including writing to other tables and invoking Pack actions that reach outside Coda entirely. So the effect of this node is defined by whoever edits the doc, not by the automation, and it can change after the automation is built. Marked destructive for that reason: nothing here can promise what a button does. This write is ASYNCHRONOUS. Coda answers HTTP 202 meaning accepted and queued, not applied. The change usually lands within a few seconds and it can still FAIL after the 202, because Coda validates the values while processing rather than while responding. Take requestId from this node's output and pass it to Coda: Get Mutation Status before any step that depends on the change having happened, and do not read the record back immediately and expect the new value.

Coda: Trigger Automation

Fire a webhook triggered automation inside a Coda doc, optionally handing it a payload. This is the node that lets a Mattering workflow hand off to logic a team already built in Coda, rather than reimplementing it: the doc's automation receives your JSON and does whatever its author configured. Two consequences follow from that and both matter. The rule must already be set up in Coda with a webhook trigger, because this endpoint invokes an existing rule and does not create one. And what actually happens is defined by whoever edits the doc, so it can change without the automation changing, which is why this is marked destructive. Coda also answers 422 here, distinctly from 400, when the rule exists but cannot process the request. This write is ASYNCHRONOUS. Coda answers HTTP 202 meaning accepted and queued, not applied. The change usually lands within a few seconds and it can still FAIL after the 202, because Coda validates the values while processing rather than while responding. Take requestId from this node's output and pass it to Coda: Get Mutation Status before any step that depends on the change having happened, and do not read the record back immediately and expect the new value.

Coda: Unpublish Doc

Take a published doc off the public web. The doc itself and all of its data survive untouched; only public access ends, and the doc can be published again later. This is the node for a scheduled takedown, or for a workflow that pulls a public page as soon as some condition is no longer true.

Coda: Update Custom Doc Domain

Update the properties of a custom domain already attached to a published doc. Coda's own API description declares this request body with NO documented fields, so there is nothing specific to offer here and everything goes through the free form body field. That is Coda's gap rather than a shortcut: if a property becomes documented, put it in the body field using Coda's own spelling and it will be sent.

Coda: Update Doc

Rename a doc or change its icon. Only those two properties are editable through this endpoint; everything else about a doc is changed from inside it. Renaming requires the token's owner to be a Doc Maker in the workspace. This one answers 200 with the updated doc rather than 202.

Coda: Update Folder

Rename a folder or change its description. Only the fields you fill in are changed. Answers 200 with the updated folder. A folder cannot be moved between workspaces through this endpoint.

Coda: Update Page

Change a page's name, subtitle, icon, cover image or hidden state, and optionally edit the content on it. The content update is the powerful part and the part to be careful with: it takes an insertion mode of append, prepend or replace, plus Markdown or HTML content. With no element ID the mode applies to the WHOLE page, so replace wipes the page and writes your content in its place. With an element ID it applies relative to that one element instead. Appending is the safe default for a recurring automation. This write is ASYNCHRONOUS. Coda answers HTTP 202 meaning accepted and queued, not applied. The change usually lands within a few seconds and it can still FAIL after the 202, because Coda validates the values while processing rather than while responding. Take requestId from this node's output and pass it to Coda: Get Mutation Status before any step that depends on the change having happened, and do not read the record back immediately and expect the new value.

Coda: Update Row

Change cell values on one existing row. Only the cells you list are touched; everything else on the row is left alone. One warning from Coda worth repeating exactly: when the row is addressed by NAME rather than by ID, an arbitrary matching row is affected. Row names are display column values and are rarely unique, so a name here can silently write to the wrong record. Use the ID. This write is ASYNCHRONOUS. Coda answers HTTP 202 meaning accepted and queued, not applied. The change usually lands within a few seconds and it can still FAIL after the 202, because Coda validates the values while processing rather than while responding. Take requestId from this node's output and pass it to Coda: Get Mutation Status before any step that depends on the change having happened, and do not read the record back immediately and expect the new value.

Coda: Update Sharing Settings

Set a doc's sharing policy. This is the node for enforcing a standard across many docs from one automation, for example turning off copying on everything in a folder that holds customer data. Only the settings you fill in are changed. Answers 200 with the resulting settings, so the output is proof of what the doc now allows.

Connecting Coda takes one credential

You generate the token yourself inside Coda, from My account in your Coda settings, using Generate API token. Coda states that once a token is created it cannot be viewed or modified, so copy it into Mattering when it is shown or generate a fresh one later. The token acts as the person who made it, so every node in this connector sees what that person sees and can do what that person can do. That makes the choice of owner the real security decision here: a token minted by a workspace Admin can rename docs, change roles and delete pages, while one minted by an Editor cannot create a doc at all unless the workspace allows any member to. Coda also supports restricted tokens, and Coda: Get Current User reports whether the token you connected is a restricted one, along with its owner, its login email and the workspace it belongs to.

1

Decide who should own the token. Every node runs as that person with their permissions, and unattended automations keep running on it, so an account the team controls beats an individual's personal login. If your workflows create docs or pages, that account needs to be a Doc Maker or an Admin in the workspace, and if they change workspace roles it needs to be an Admin.

2

In Coda, open My account in your settings and use Generate API token. Name it something you will recognise later, because Coda: Get Current User returns the token name and that is how you identify which connection is acting when something unexpected happens. Copy the value straight away: Coda does not show it again.

3

In Mattering Automations, open Connectors, click Add Connector and choose Coda. Create a new credential and paste the token into it. There is nothing else to fill in.

4

Click Test Connection. Mattering calls the API's whoami endpoint, which takes no parameters at all and is the cheapest authenticated call on the API, so a success proves the token and the header wiring in one request. An invalid or revoked token answers a plain 401.

5

All 65 Coda nodes appear in the canvas palette. Run Coda: Get Current User first to confirm which account and workspace you are acting as, then Coda: List Docs, which is the source for every doc picker in the connector. One thing to expect from that list: Coda returns docs the token owner has opened at least once, in the same order as their docs page, so a doc shared with them but never visited will not be in it.

6

The token is stored encrypted, never appears in workflow logs, and can be revoked from inside Coda at any time, which ends the connection immediately.

Common uses for the Coda MCP

Stand up a per client or per project doc from a template

Coda: Create Doc takes a source doc, and copying is the interesting half: every table, formula, button and automation in the template comes with the copy, so a Coda doc becomes a repeatable workspace an automation can create on demand. Pair it with Coda: Create Folder to build the whole area in one run, then Coda: Insert or Upsert Rows to seed the new doc with what the workflow already knows about the client. Two conveniences make this practical rather than fiddly. Creating a doc is one of the few writes that answers immediately with the finished doc rather than a queued 202, so the new doc id and browser link are available to the very next step. And the token owner has to be a Doc Maker or an Admin for it to work at all, which is worth settling before you schedule anything rather than discovering it as a 403.

Keep a Coda table in step with another system, safely re-runnable

Coda: Insert or Upsert Rows is the node that makes a repeating sync survive being run twice. With no key columns it always inserts. Name one or more key columns and Coda looks for rows whose keys match and updates them instead of adding duplicates. Read Coda's own caution before you rely on it: when several rows match the key, all of them are updated, so a key that is not genuinely unique quietly rewrites more rows than you meant. It works on base tables only and never on views, which Coda: List Tables tells you by reporting the table type, and column ids come from Coda: List Columns, where a calculated column is one you cannot write to at all. Because this write returns a queued 202, put Coda: Get Mutation Status after it whenever a later step depends on the rows being there.

Write the result of a run onto a real page, not into a row

Most integrations can only append a row. Coda: Update Page takes an insertion mode of append, prepend or replace plus Markdown or HTML, so a workflow can write a weekly summary, an incident note or an AI-drafted status onto the page a team actually reads. Appending is the right default for anything recurring: with no element id, replace applies to the whole page and wipes it. Coda: Create Page adds a new page instead, optionally as a subpage, and Coda: List Page Content gives you the element ids you need to edit or remove one block rather than the lot. Going the other way, Coda: Begin Page Content Export and Coda: Get Page Content Export Status turn a whole page into Markdown or HTML for a summarizer, which is a better input to an AI step than a list of elements.

Poll a large table on a schedule without re-reading it every time

Coda: List Rows accepts a sync token: pass back the nextSyncToken from the previous run and Coda returns only the rows relevant since that call. It advances by itself, needs no clock and cannot drop a row at a window boundary, which makes it a better change feed than any date filter and much cheaper on a big table. Set the value format deliberately while you are there, because Coda's own default flattens multi value cells to a comma delimited string. One thing not to substitute for it: Coda offers sorting by updated time, but warns that this ordering ignores updates to calculated values, so a row whose formula output changed does not move in it. In a doc that computes things for itself, which is most of them, that misses exactly the rows you care about.

Hand off to logic the team already built inside the doc

Coda: Push Button presses a button in a table and Coda: Trigger Automation fires a webhook-triggered rule with a payload of your choosing, which means a Mattering workflow can call logic a team already built rather than reimplementing it. Both are marked destructive here, and the reason is honest rather than cautious. Coda's own note on pressing a button is that the API only checks that the token can write to that table, while the button itself can act anywhere in the doc, including invoking Pack actions that reach outside Coda entirely. So what these nodes do is defined by whoever edits the doc and can change after your automation is built, without your automation changing. Worth using, worth keeping behind a condition or an approval step, and worth reading the button before you schedule it.

Seat hygiene and a sharing audit that runs itself

Coda: List Workspace Members returns each person's role with when they last registered, when their role last changed, when they were last active and how many docs they own, which is a genuine licence audit rather than a headcount. Coda: List Workspace Role Activity adds the same picture month by month, split into active and inactive counts per role. Feed either into Coda: Change Workspace User Role to demote a Doc Maker who has not touched anything in ninety days, which is what actually frees a paid seat, remembering that this one needs an Admin token. On the sharing side, Coda: List Permissions is the audit: as well as individuals and groups, a doc can be shared with an entire domain, an entire workspace, or with anyone holding the link. Coda: Get Sharing Settings answers whether viewers may copy a doc outright, and Coda: Delete Permission and Coda: Update Sharing Settings are how a workflow acts on what it found.

Example: Onboard a client into Coda and confirm the writes actually landed

Built on the Automations canvas in a few minutes, or described in plain language to Matter and built for you.

1

Trigger: a deal moves to won in your CRM, or a scheduled check finds a new row waiting. This connector has no trigger nodes, because the Coda API offers no subscription surface to build them from, so Coda workflows start from a schedule or from another system's event.

2

Coda: Create Folder makes the client's area in the workspace. It answers with the finished folder rather than a queue receipt, so the folder id is available immediately.

3

Coda: Create Doc copies your onboarding template into that folder, bringing its tables, formulas and automations with it, and returns the new doc id and browser link. The token owner must be a Doc Maker or an Admin for this step, which is a role question rather than a plan question.

4

Coda: List Tables and Coda: List Columns read the new doc's structure so the next step addresses columns by id instead of by a name someone might rename later.

5

Coda: Insert or Upsert Rows writes the client's details into the tracker table, with the CRM record id named as the key column so re-running the workflow updates the same row rather than creating a second one.

6

Coda: Get Mutation Status takes the requestId from that step and confirms the rows were applied. This is the step people skip. Coda answered 202 meaning queued, the edit can still fail during processing, and without this check the next step reads a table that may not contain what you just wrote.

7

Coda: Update Page appends a kickoff summary to the doc's overview page in Markdown, so the humans see the context rather than only the data. Append rather than replace, because replace with no element id clears the page.

8

Coda: Add Permission shares the doc with the account manager, after Coda: Get Sharing Metadata has confirmed this token is allowed to share it, so the workflow fails politely instead of collecting a 403 halfway through.

9

A task is opened in Mattering Productivity with the doc link, so a person confirms the file looks right before the client ever sees it.

Coda MCP questions, answered

What can this connector actually do in Coda?

65 nodes: 38 that read and 27 that act. Reads cover the current user, docs, folders, pages and page content, page export status, tables, columns, rows, named formulas, controls, permissions and sharing metadata and settings, doc categories, custom doc domains and their DNS provider, workspace members and role activity, doc, page, Pack and Pack formula analytics with their summaries and the analytics freshness check, a Pack lister, browser link resolution, principal search and mutation status. Writes cover creating docs, folders and pages, updating docs, folders, pages and sharing settings, inserting and upserting rows, updating and deleting rows, deleting docs, pages, page content, folders and permissions, adding permissions, publishing and unpublishing docs, adding, updating and deleting custom doc domains, adding a go link, changing a workspace user role, starting a page export, pressing a button and triggering a doc automation. Ten of those are flagged destructive. Not included: the Pack build and publish lifecycle, which is 59 further operations driven by Coda's own command line tool against a local Pack project, and trigger nodes, because the API offers no subscription surface.

Does this work with Claude, ChatGPT, or other AI assistants?

Yes. Mattering exposes these nodes over MCP, the open protocol for connecting AI assistants to tools, so any MCP-capable assistant, including Claude and ChatGPT, can connect to your workspace and work with Coda through them. Matter, the assistant built into the platform, uses the same nodes natively. The same nodes are also steps on the automation canvas, so a workflow an assistant helps you design can then run on a schedule with nobody present. A sensible split with Coda is to give an assistant the read nodes freely and put the ten destructive ones behind a condition or an approval step, since Coda: Delete Doc removes every page and row in a doc at once.

Does Coda publish its own MCP server?

Yes, and this page would be worth less if it did not say so. Coda's API reference links a guide to the Superhuman Docs MCP server, describing it as optimized for LLM usage patterns and often exposing more granular methods for accessing and modifying data. The guide describes a conversational surface: connect an AI client such as Claude, ChatGPT or Cursor, share a doc link, describe the outcome, and the agent creates the doc, builds the table or rewrites the page. It is good at that and we are not going to run it down. What this connector does is a different job. These 65 nodes are workflow steps as well as MCP tools, so they run unattended on a schedule or from another system's event, chain with every other connector on the same canvas in one workflow, hold one credential in a shared workspace store rather than in each person's local client config, carry destructive flags, and turn Coda's queued 202 writes into something a following step can verify with a request id. If you want an agent that writes a doc while you talk to it, use theirs. If you want Coda to be a step in a process that happens whether or not anyone is at a keyboard, that is this.

Coda is becoming Superhuman Docs. Does that break the integration?

No, and it is worth being precise about what has actually moved. The rebrand is real: Coda's reference documentation now lives at docs.superhuman.com, titles itself the Superhuman Docs API, and describes the product as Superhuman Docs, formerly Coda. The API itself is unchanged. This connector calls coda.io/apis/v1, which is where every existing Coda integration points and which still answers, and the same tokens work either way. Coda's published spec now also names docs.superhuman.com/apis/v1 as a server, so both hosts serve the same API today and the migration is visibly still in flight, with some marketing paths redirecting back to coda.io. We have pinned the long-standing base rather than chasing a documentation redirect, and the alternative is recorded in the connector so switching is a one line change if it is ever needed. The connector keeps the name Coda because that is what the product is still called in its own URLs and what anyone building an integration is looking for.

Do I need a paid Coda plan to use this?

No, with one exception that is worth knowing before you build. Coda's API reference states plainly, under a heading written for this question, that the API is available to all of its users free of charge in both free and paid workspaces, and that usage is governed instead by the role of the user whose token you are using. Two roles matter. Creating a doc, and renaming a doc or page, require the token owner to be a Doc Maker or an Admin in the workspace, and Coda notes an Editor is auto promoted when the workspace has the option allowing any member to create docs. Changing a workspace user role requires Admin. The exception is Coda: List Page Analytics, which Coda documents as returning HTTP 401 when the doc is not in an Enterprise workspace. Nothing else in the connector is plan gated.

Why does one node fail with a 401 while every other node works?

It is almost certainly Coda: List Page Analytics, and it is a plan limit wearing an authentication error's clothes. Coda's own documentation for that endpoint says it returns a 401 when the given doc is not in an Enterprise workspace. A 401 normally means a bad or revoked token, so the natural conclusion is that the credential is broken, and it is not: if the other 64 nodes work with the same token, the token is fine and the workspace is simply not on Enterprise. The connector attaches a hint to a 401 from that node specifically for this reason. Doc level analytics, Pack analytics and the analytics freshness check are not gated this way. A 401 from any other node, or from Test Connection, really is the credential, and because Coda shows a token once and never again, the fix is to generate a new one rather than to look for a refresh.

My workflow wrote to a table, reported success, and nothing changed. Why?

Because Coda accepted the write rather than performing it. Coda's documentation states that edits made through the API are not immediate, that these endpoints return HTTP 202 instead of 200 to indicate the edit has been accepted and queued for processing, that this generally takes a few seconds, and that the edit may fail if invalid. Fourteen operations in this connector behave that way, covering the row writes, the page writes, doc deletion, publishing, custom domains, button presses and automation triggers. Two failure shapes follow. A step that reads the record back immediately reads the value from before the write. And a write that returned 202 can still fail during processing, because Coda validates the values while processing rather than while responding, leaving nothing in the doc and no error in the run. The fix is built in: those nodes return Coda's requestId as an output, the connector marks the response when Coda answers 202, and Coda: Get Mutation Status takes that request id and answers whether the edit completed. Read its warning field too, which is populated when a write succeeded but had to be corrected, such as invalid HTML in page content. Check it after a short wait rather than in a tight loop, and note that Coda does not guarantee the status stays available more than a day, so it is a shortly-after check and not an audit trail.

What are Coda's rate limits, and what should I watch out for when deleting?

Coda documents five separate limit classes, for reading, writing, writing doc content, listing docs and reading analytics, applied per user across every endpoint sharing a limit and across all docs, and says they are subject to change without notice. It does not put the figures in its published API description, so no number appears here and none should be invented; treat a 429 as the signal, back off and retry, and prefer one wide read over a loop of narrow ones. On deleting, three things deserve care. Coda: Delete Page Content removes everything on the page when you leave the element list empty, which inverts how most delete endpoints behave. Coda: Delete Page takes the page's subpages with it, and because a Coda table lives on a page it can take a table with it too, which is data that looks like it belongs to the doc rather than to the page. And addressing a row by name rather than id is genuinely dangerous, because Coda selects an arbitrary match when several share a name and a row's name is only the display column's value. The pickers in this connector store ids for exactly that reason. One node is guarded: Coda refuses to delete a folder that still contains docs.

65 nodes waiting on the canvas

Put Coda to work inside your workspace

Connect once, then use every node in visual automations and AI agent workflows across the Mattering platform.

All product names, logos, and brands are property of their respective owners and are used for identification purposes only. Use of these names, logos, and brands does not imply endorsement or affiliation. Coda is a product of its respective owner; Mattering is an independent platform.

Start Free Explore our Products