Menu

Mattering Automations Coda integration

Connect Coda to Mattering Automations: docs, folders, pages and page content, tables, columns and rows, permissions and sharing, publishing, workspace roles and analytics as workflow steps, authorized with a single API token you generate in your Coda account.

The Mattering Automations Coda integration puts the Coda v1 API on your automation canvas: list and create docs and folders, read and write pages and page content, read tables, columns, formulas and controls, insert, upsert, update and delete rows, audit and change sharing, publish docs and attach custom domains, manage workspace members and roles, and read doc, page and Pack analytics. Sixty five nodes in total, thirty eight that read and twenty seven that act, ten of them flagged destructive.

One naming note first, because the vendor is mid rebrand and it trips people up. Coda is being renamed Superhuman Docs. The reference documentation now lives at docs.superhuman.com and titles itself the Superhuman Docs API, and the spec describes the product as Superhuman Docs, formerly Coda. Nothing about the API has changed: this integration calls coda.io/apis/v1, the same tokens work, and the endpoints are the same ones. The connector keeps the name Coda because that is what the product is still called in its own URLs. If a link in this guide takes you to a Superhuman page, that is expected rather than a mistake.

The credential is a single API token you generate yourself inside Coda and paste into Mattering. There is no OAuth flow, no client id and no secret. The one decision that carries weight is whose token it is, because a Coda token acts as its owner: everything these nodes can see and do is what that person can see and do, and two operations need a specific workspace role. Two behaviours are worth reading before you build anything, and both are covered in full below: most writes come back as accepted and queued rather than done, and one analytics node reports a plan limit as a 401 that looks exactly like a broken credential. This guide ends with the complete node reference.

Before you start

  • A Coda account. Coda states in its API reference that the API is available to all of its users free of charge, in both free and paid workspaces, so there is no plan to buy to get started and no separate developer programme to join.
  • A decision about which Coda account owns the token. Every node runs as that person and inherits their permissions rather than the workspace's full access, and scheduled automations keep running on it, so an account the team controls beats an individual's personal login.
  • Doc Maker or Admin in the workspace, if your workflows will create docs or pages or rename a doc or page. Coda documents this as a role requirement rather than a plan one, and notes that an Editor is auto promoted when the workspace has the option allowing any member to create docs. A plain Editor in a workspace without that option gets an HTTP 403 from Coda: Create Doc.
  • Workspace Admin, if your workflows will use Coda: Change Workspace User Role. Coda only succeeds on that endpoint when the requesting user has admin permissions in the workspace.
  • An Enterprise workspace, and only if you intend to use Coda: List Page Analytics. Coda's documentation for that endpoint states it returns a 401 when the doc is not in an Enterprise workspace. It is the one plan gate in the whole integration, and the verify path below deliberately does not touch it.
  • A Mattering workspace with access to the Automations app.

Generate a Coda API token

Coda issues one opaque token per user, sent as an Authorization Bearer header. There is nothing else to configure: no client id, no secret, no region and no host. The token carries the full authority of the account that made it, so pick the owner before you generate anything.

Sign in to Coda as the account that should own the connection. If you are unsure, prefer a team-owned account over a personal one, because scheduled automations keep running on this credential after whoever set them up moves on.
Open My account in your Coda settings and use Generate API token. Give it a name you will recognise later, such as the workflow or the team it serves.
Coda shows the token once. Its own documentation states that after a token is created it cannot be viewed or modified, so copy the value into Mattering immediately. If you lose it, there is nothing to recover: generate a new token and replace the credential.
The token acts as its owner. Anything that account can see, these nodes can see, and anything it can change, these nodes can change. Coda also supports restricted tokens; Coda: Get Current User reports whether the token you connected is restricted, along with its owner, login email, token name and workspace.

Connect Coda to Mattering

In Mattering Automations, open Connectors and click Add Connector.
Choose Coda from the list.
Click Create new credential and paste your API token into the token field. There are no other fields to fill in.
The token is stored encrypted in Google Secret Manager and never appears in workflow logs. Revoking it from inside Coda ends the connection immediately, and because Coda cannot show an existing token again, replacing a credential means generating a new token rather than looking one up.
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 missing token answers a plain HTTP 401.
All 65 Coda nodes appear in your canvas palette, grouped as 38 read nodes and 27 action nodes.

Verify it works

Open any automation canvas and check the palette for a Coda section. Drop Coda: Get Current User onto the canvas and run a test step. It is the natural probe for this integration because it takes no parameters and answers the question that governs everything else: which Coda account this connection acts as. Read the workspace, the login email and the token name in the response, and note the restricted flag. Every other node inherits that account's permissions, so if a later read returns less than you expected, this is where the explanation usually starts.

Now run Coda: List Docs without changing anything. It is the source for every doc picker in the integration, so a good response here means the pickers will populate. One thing to expect rather than debug: Coda returns the docs this account has opened at least once, ordered the same way as its docs page, so a doc that was shared with the account but never visited will not appear in the list. Open it once in the browser and it shows up.

Open the Doc picker on a node such as Coda: List Tables and confirm it lists real doc names. Choose one, and the table picker on that node should populate from it, grouped by whether each entry is a base table or a view. Pick a table and the row and column pickers elsewhere populate in turn. That chain working three deep is the strongest single confirmation that the credential, the pickers and the connector wiring are all fine. Everything in this verify path is read-only, so it cannot reach any of the ten destructive nodes and is safe to re-run whenever you want to check a connection.

Node reference

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

Read and query nodes 38

Coda: Get Analytics Last Updated

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

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

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

coda_whoami

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

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

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

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

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

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

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

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

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

coda_get_page_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

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

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

coda_get_acl_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

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

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

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

coda_list_custom_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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

coda_add_custom_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

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

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

coda_begin_page_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

coda_change_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

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

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

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

coda_delete_custom_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

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

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

coda_delete_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

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

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

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

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

coda_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

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

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

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

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

coda_update_custom_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

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

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

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

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

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

Using the integration

Writes are accepted, not completed, and this is the thing to internalize

Coda's documentation is explicit that changes made through the API are not immediate: those endpoints return HTTP 202 instead of a standard 200, indicating 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 behind these nodes behave that way, covering Coda: Insert or Upsert Rows, Coda: Update Row, Coda: Delete Row, Coda: Delete Multiple Rows, Coda: Create Page, Coda: Update Page, Coda: Delete Page, Coda: Delete Page Content, Coda: Begin Page Content Export, Coda: Delete Doc, Coda: Publish Doc, Coda: Add Custom Doc Domain, Coda: Push Button and Coda: Trigger Automation. Two distinct hazards come out of that and only the first is obvious. A following step that reads the record back straight away frequently reads the old value. And a write that returned 202 can still fail during processing, because Coda validates the values while processing rather than while responding, which leaves nothing in the doc and no error anywhere in the run. The integration handles this in three ways rather than one. Every affected node exposes Coda's requestId as an output you can drag into the next step. The connector attaches a marker to the response data whenever Coda answers 202, naming the request id and the node that resolves it. And each of those nodes ships a sample output carrying a real 202, so the canvas offers requestId as a draggable path before you have ever run the node. Put Coda: Get Mutation Status after any queued write that a later step depends on, pass it the request id, and it answers whether the edit completed. Read its warning field as well: it is populated on writes that succeeded but had to be corrected on the way in, such as invalid HTML in page content, which is worth surfacing rather than discarding. Check it after a short wait rather than in a tight loop, and note Coda does not guarantee status stays available more than a day after the mutation completed, so it is a shortly-after check and not an audit trail. Not every write is queued: Coda: Create Doc, Coda: Create Folder, Coda: Update Doc, Coda: Update Folder and Coda: Update Sharing Settings answer with the finished object, so their ids are usable immediately.

Address things by id, not by name

Coda lets most paths take either an id or a name for a table, page, row, column, formula or control, and recommends sticking with ids because names are fragile and prone to being changed by a doc's users. The rename is the harmless half, since it fails loudly with a 404. The dangerous half is the duplicate: Coda states that when several objects share a name an arbitrary one is selected, and repeats that specifically for updates and again for deletes. Rows make this sharper than it sounds, because a row's name is simply the value of the table's display column, so row names are only as unique as that column's data, which is usually not at all. A table with three rows called Follow up has three rows that a name-addressed Coda: Delete Row might remove. Every such field in this integration is fed by a picker that stores the id, and the row picker carries the row id on its own second line so two entries labelled the same stay distinguishable in the list that drives a delete. If you are templating a value in from an earlier step, template the id.

Reading rows: value format, sync tokens and freshness

Coda: List Rows and Coda: Get Row both take a value format, and the default matters. Coda's own default is simple, which flattens array cells such as multi selects into a comma delimited string, so a value that itself contains a comma becomes indistinguishable from two values. These nodes default to simpleWithArrays instead, which keeps arrays as real arrays, and the field description names all three settings including Coda's own default so nothing is hidden. The third, rich, is lossless: text comes back as Markdown and currency, lookup, image, person and hyperlink values come back as structured objects. Coda: List Rows also accepts a sync token, which is the best incremental mechanism in this API: pass back the nextSyncToken from your previous run and Coda returns only the rows relevant since that call. It advances by itself, needs no clock and cannot lose a row at a window boundary, which makes it far cheaper than re-reading a large table on a schedule. Do not substitute sorting by updated time for it: Coda warns that ordering ignores updates to calculated values, so a row whose formula output changed does not move in it, which in a doc that computes things for itself misses most of the interesting rows. Separately, thirteen doc-reading nodes offer a require latest option. Coda serves reads from a recent snapshot of the doc that may be slightly stale, and this option asks for the newest version instead, with Coda answering HTTP 400 rather than serving something older. That is right immediately after a write and wrong in a nightly export, which is why it sits on the node rather than on the connection.

Roles, plans and the one gate that lies about itself

Coda's API reference states that the API is available to all of its users free of charge in both free and paid workspaces, and that usage is instead subject to the role of the user whose token is making the request. Two roles matter here. Creating a doc requires the token owner to be a Doc Maker or an Admin, with an Editor auto promoted when the workspace has the option allowing any member to create docs, and Coda applies the same requirement to creating a page and to renaming a doc or a page. Changing a workspace user role requires Admin. Those are 403s when they bite, which is a clean signal. The exception is Coda: List Page Analytics, whose documentation states it returns a 401 when the given doc is not in an Enterprise workspace. That single node therefore looks exactly like a broken credential on any other plan, while the other 64 nodes work perfectly with the same token. The connector attaches a node-specific hint to a 401 from that node for exactly this reason. Doc analytics, Pack analytics and Coda: Get Analytics Last Updated are not gated this way.

Writing to pages instead of rows

Most integrations can only append a row. Coda: Update Page can write onto the page a team actually reads, taking an insertion mode of append, prepend or replace plus Markdown or HTML content. The mode is the part to be careful with: with no element id it applies to the whole page, so replace clears the page and writes your content in its place, which is why append is the right default for anything recurring. With an element id it applies relative to that one element instead, and the element ids come from Coda: List Page Content, which returns a page block by block with each block's type, text, style and indent. Coda: Create Page adds a page rather than editing one, optionally as a subpage, and can take authored Markdown or HTML content, a full page embed of an external URL, or a copy of an existing page from this or another doc. Going the other way, Coda: Begin Page Content Export turns a whole page into Markdown or HTML and Coda: Get Page Content Export Status collects it once the status reads complete. The download link it returns is a short lived signed URL that grants access to the page's contents to anyone holding it, so fetch it promptly with an HTTP node and do not persist it.

Deletes, and which ones can take more than you asked for

Ten nodes are flagged destructive, and they are not equally bad. Coda: Delete Doc is the worst by a distance: one doc can hold every page and every row a team has, and Coda documents no way to undo it through the API. 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. Read what is on a page before scheduling this against it. Coda: Delete Page Content inverts the usual default: leaving the element list empty deletes everything on the page rather than nothing. Coda: Delete Row is the one most exposed to the id-or-name problem above, while Coda: Delete Multiple Rows takes ids only, which makes it the safer of the two despite sounding worse. Coda: Delete Permission can cut off many people at once when the permission it removes belongs to a domain, a workspace or to anyone with the link, so read the principal on the entry first. Coda: Delete Custom Doc Domain breaks every existing link to the custom address, though the doc stays published at its coda.io URL. Coda: Push Button and Coda: Trigger Automation are flagged for a different reason, covered below. One node is genuinely guarded: Coda refuses to delete a folder that still contains docs, so Coda: Delete Folder cannot destroy documents.

Handing off to logic that lives inside the doc

Coda: Push Button presses a button in a table and Coda: Trigger Automation fires a webhook-triggered rule in a doc with a payload of your choosing. Both let a Mattering workflow call logic a team already built in Coda rather than reimplementing it, and both are marked destructive for an honest reason rather than a cautious one. Coda's own authorization note on pressing a button is that the API checks only that the token can write to that table, while 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 these nodes is defined by whoever edits the doc, not by your automation, and it can change after the automation is built without the automation changing. Two practical notes. The rule behind Coda: Trigger Automation must already exist in Coda with a webhook trigger, because this endpoint invokes an existing rule and does not create one, and Coda answers 422 distinctly from 400 when the rule exists but cannot process the request. There is also no way to list a doc's rules through this API, so the rule id is a value you copy from Coda rather than pick from a list.

Sharing, publishing and workspace administration

Coda: List Permissions is the audit node: it returns every share on a doc with its access level and its principal, and the principal is where the surprises are, because as well as an individual or a group a doc can be shared with an entire domain, an entire workspace, or with anyone holding the link. Coda: Get Sharing Settings reads the policy rather than the list, including whether viewers may copy the doc outright, which is worth auditing on anything sensitive because a copy leaves your governance entirely. Coda: Get Sharing Metadata answers what this token is allowed to do before you try it, so a workflow can fail politely rather than collecting a 403 midway, and Coda: Search Principals is the lookup step before Coda: Add Permission and the only way to obtain a group id, returning at most twenty users and twenty groups and nothing at all for an empty query. On the publishing side, Coda: Publish Doc makes a doc readable by anyone who finds the URL with no Coda account required, and its discoverable setting goes further than that, so treat this as a genuine publication step rather than a sharing tweak. It is reversible with Coda: Unpublish Doc. For seats, Coda: List Workspace Members returns each member's role alongside when they were last active and how many docs they own, Coda: List Workspace Role Activity gives the same picture month by month split into active and inactive counts, and Coda: Change Workspace User Role acts on it, needing an Admin token.

On the automation canvas, and from AI assistants over MCP

Coda nodes chain with every other node in Mattering. A won deal in a CRM can run Coda: Create Folder and Coda: Create Doc from a template, seed it with Coda: Insert or Upsert Rows, confirm the write with Coda: Get Mutation Status and then open a Productivity task for a person to check it. A scheduled job can read a table with Coda: List Rows and a sync token, or read a Coda link somebody pasted into a form by resolving it with Coda: Resolve Browser Link, which turns any browser URL into the type and id an API call needs. There are no trigger nodes here, because the API offers no subscription surface to build them from, so Coda workflows start from a schedule or from another system's event. Every node also 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. Coda runs an MCP server of its own, linked from its API reference and described in its guide as a conversational surface where you connect an AI client, share a doc link and describe an outcome. That is a different job from this one and both can coexist: the advantage of running Coda here is that the same nodes are canvas steps, so a workflow runs on a schedule with nobody present, chains with every other connector, and holds one credential in a shared workspace rather than in each person's local client config. Given the ten destructive nodes, the sensible split is to give an assistant the read nodes and keep the deletes and the two doc-defined nodes behind a condition or an approval step.

Troubleshooting

One node fails with a 401 while every other node works fine
That node is almost certainly Coda: List Page Analytics, and this is a plan limit disguised as an authentication error. Coda's documentation for that endpoint states it returns a 401 when the given doc is not in an Enterprise workspace. Because a 401 normally means a bad token, the natural reaction is to regenerate the credential, which will not help. The test is simple: if Coda: Get Current User and the other read nodes work with the same token, the token is fine and the workspace is not on Enterprise. The connector attaches a hint to a 401 from that node for this reason. Doc analytics, Pack analytics and Coda: Get Analytics Last Updated are not gated this way, so use those instead if the page-level split is not essential.
Test Connection fails with a 401, or every node fails at once
This one really is the credential. Coda returns a plain 401 with an Unauthorized message for a missing, malformed or revoked token, so there is no ambiguity about the shape. Check three things in order. Was the token revoked or the owning account deactivated in Coda. Was the whole token pasted, since a truncated value fails exactly the same way. And is this the credential you think it is, which Coda: Get Current User answers by returning the token name and the owning account. The fix is always to generate a new token rather than to look up the old one: Coda states a token cannot be viewed or modified after it is created, which is why there is nothing to refresh.
A write reported success but nothing changed in the doc
Coda accepted the write rather than performing it. Coda's documentation states that these endpoints return HTTP 202 instead of 200, meaning the edit has been accepted and queued for processing, that it generally takes a few seconds, and that the edit may still fail if invalid. Fourteen operations in this integration behave that way. Take the requestId from the node's output, pass it to Coda: Get Mutation Status, and read both the completed flag and the warning field, which is populated when a write succeeded but had to be corrected, such as invalid HTML in page content. If completed is false, check again after a wait rather than in a tight loop. If the mutation failed outright, the usual causes are a value that does not fit the column's format, which Coda: List Columns will show you, or a write aimed at a view rather than a base table, since row inserts and upserts work only on base tables.
A step after a write read the old value
Same root cause as the previous entry, different symptom, and it is the more confusing of the two because nothing looks like it failed. The write was queued, the read ran immediately, and Coda served the read from a snapshot taken before the edit landed. Two fixes, and they stack. Put Coda: Get Mutation Status between the write and the read so the workflow waits for the edit to be applied rather than assuming it. And turn on the require latest option on the reading node, which asks Coda for the newest version of the doc and answers HTTP 400 rather than serving something older. Leave that option off in scheduled bulk reads such as a nightly export, where a 400 on a busy doc is worse than a few seconds of staleness.
The wrong row was updated or deleted
Almost always the id-or-name behaviour. Coda accepts either an id or a name in those paths and states that when several objects share a name an arbitrary one is selected, and it repeats that specifically for updates and for deletes. A row's name is only the value of the table's display column, so duplicates are normal rather than exceptional. Use the picker rather than typing a value, because it stores the id, and if the value is templated from an earlier step, template the id rather than the label. When deleting several rows, prefer Coda: Delete Multiple Rows, which takes ids only and so cannot be given an ambiguous name at all. Coda documents no way to undo a delete through the API, so this is worth fixing in the workflow rather than after the fact.
A doc that definitely exists is missing from Coda: List Docs or from a doc picker
Coda documents this list as the docs accessible by the user which they have opened at least once, returned in the same order as the docs page. So a doc that was shared with the token's owner but never actually opened by them is not in the list, and no doc picker will show it either. Open it once in the browser as that account and it appears. The second cause is the account itself: every node runs as the token's owner rather than as the workspace, so run Coda: Get Current User and confirm the login email and workspace are the ones you meant. If the doc lives in a different workspace, that token cannot see it at all.
Creating a doc or renaming a page fails with a 403
This is a role, not a plan, and Coda is explicit about it. Creating a doc requires the token's owner to be a Doc Maker or an Admin in the workspace, and Coda applies the same requirement to creating a page and to renaming a doc or a page. An Editor is auto promoted when the workspace has the Any member can create docs option enabled, so the same token can succeed in one workspace and fail in another. Coda also notes this applies to the API and to any integration using it, so it is not something a different tool avoids. Either promote the token's owner in the Coda workspace, enable that workspace option, or generate the token from an account that already holds the role. Coda: Change Workspace User Role has its own version of this: it only succeeds when the requesting user has Admin permissions.
Rows come back with multi select values run together, or values look wrong
Check the value format on the node. Coda's own default, simple, flattens array cells into a comma delimited string, so a multi select becomes one string and a value containing a comma becomes indistinguishable from two values. These nodes default to simpleWithArrays instead, which keeps arrays as arrays, so a node showing the flattened shape has usually had that field changed. Use rich when you need lossless values: text comes back as Markdown, and currency, lookup, image, person and hyperlink values come back as structured objects rather than flattened text. Two related things that look like bugs and are not. A calculated column cannot be written to at all, which Coda: List Columns flags. And a formula built on today, now or the current 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 behind an API call.
Requests start failing with a 429
Coda applies rate limits per user across every endpoint that shares a limit and across all docs, with separate classes for reading, writing, writing doc content, listing docs and reading analytics, and says the figures are subject to change at any time without notice. Coda does not publish the numbers in its machine-readable API description, so this guide does not quote any. Coda's own advice is what to build on: check for a 429, back off and retry. The durable fix is shape rather than pacing. Prefer one wide read to a loop of narrow ones, use the sync token on Coda: List Rows so a scheduled poll fetches only what changed, and remember that writing doc content has its own limit class, so a workflow that appends to a page inside a loop hits a different ceiling than one that reads.
A picker stays empty, or a downstream picker never populates
Start with the lister behind it. Each picker is sourced from a node in this integration, so run that node on its own first: if Coda: List Docs returns nothing, no doc picker will populate either. Then check whether the parent field is set, because the chain is scoped: the table picker needs a doc, and the row and column pickers need a table. A few fields are free text by design rather than broken pickers. The request id on the mutation status nodes is free text because its value comes from a previous node in the same run, so drag it from the earlier step rather than looking for a list. The rule id on Coda: Trigger Automation is free text because Coda's API has exactly one automations operation, the trigger itself, and offers no way to enumerate a doc's rules. The category names on Coda: Publish Doc, the row id list on Coda: Delete Multiple Rows and the doc and Pack id filters on the analytics nodes are free text because they take several values at once rather than one, and each of those field descriptions names the lister to read the values from. One list has a different shape worth knowing if you are building your own path expressions: Coda: List Custom Doc Domains returns its rows under a customDocDomains key rather than the items key the rest of the API uses.

Coda 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