> For the complete documentation index, see [llms.txt](https://docs.coupler.io/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.coupler.io/sources/category/files-and-tables/coda.md).

# Coda

Connect Coda docs, tables, and rows to Google Sheets, BigQuery, or your data warehouse via Coupler.io for seamless reporting and automation.

Coda is an all-in-one doc platform that combines documents, spreadsheets, and databases into a single workspace. Teams use Coda to build internal tools, track projects, manage data, and automate workflows — all without writing code.

Connecting Coda to Coupler.io lets you pull your Coda tables, docs, and structured data into any destination for reporting, analysis, or AI-assisted workflows.

## Why connect Coda to Coupler.io?

* **Export Coda tables to spreadsheets or BI tools** — send rows from any Coda table directly to Google Sheets, Excel, BigQuery, or Looker Studio
* **Combine data across docs** — use Append or Join transformations to merge data from multiple Coda docs or tables into one dataset
* **Feed Coda data to AI tools** — route your structured Coda data to ChatGPT, Claude, Gemini, Perplexity, Cursor, or OpenClaw for analysis and summarization
* **Keep data in sync automatically** — schedule recurring refreshes so your reports always reflect the latest Coda data

## Prerequisites

* A Coda account (free or paid)
* A Coda API key — you can generate one in your [Coda account settings](https://coda.io/account) under **API settings**
* Read access to the docs, tables, or pages you want to export

## Quick start

{% hint style="success" %}
Start with the **Rows** entity if you want to export structured table data — it's the most common use case and gives you the most actionable dataset.
{% endhint %}

## How to connect

{% stepper %}
{% step %}
**Create a new data flow in Coupler.io.** Go to your Coupler.io workspace, click **Add data flow**, and search for **Coda** as your source.
{% endstep %}

{% step %}
**Enter your Coda API key.** In your Coda account, navigate to **Account settings → API settings** and generate a new API token. Copy the token and paste it into the API key field in Coupler.io.
{% endstep %}

{% step %}
**Select an entity.** Choose which type of data you want to pull — for example, **Rows** to export table data, **Docs** to get a list of your documents, or **Pages** to pull page metadata.
{% endstep %}

{% step %}
**Choose a destination.** Select where you want your Coda data to land — Google Sheets, Excel, BigQuery, Looker Studio, or an AI destination like ChatGPT or Claude.
{% endstep %}

{% step %}
**Run the data flow.** Click **Run** to execute a manual sync. Once it completes successfully, your Coda data will appear in your chosen destination.
{% endstep %}
{% endstepper %}

## Available entities

| Entity      | What it contains                              |
| ----------- | --------------------------------------------- |
| Docs        | List of all Coda docs in your account         |
| Categories  | Doc categories and labels                     |
| Permissions | Access and sharing settings per doc           |
| Pages       | Pages within a doc, including metadata        |
| Tables      | Table definitions inside a doc                |
| Formulas    | Named formulas defined in a doc               |
| Controls    | Interactive controls (buttons, sliders, etc.) |
| Rows        | Row-level data from a specific table          |

## Coda data overview

Coupler.io can pull eight types of data from Coda. Most use cases center on **Rows** (the actual data inside your Coda tables), but the structural entities like Docs, Pages, and Tables are useful for auditing your workspace or building dynamic pipelines.

## Entities overview

| Entity      | Best for                                    |
| ----------- | ------------------------------------------- |
| Docs        | Inventory of all docs in your workspace     |
| Categories  | Organizing and filtering docs by category   |
| Permissions | Auditing who has access to which docs       |
| Pages       | Listing and tracking pages within a doc     |
| Tables      | Discovering table structure within a doc    |
| Formulas    | Exporting named formula definitions         |
| Controls    | Tracking interactive controls in a doc      |
| Rows        | Exporting the actual data stored in a table |

## Docs

#### Available fields

| Field       | Description                           |
| ----------- | ------------------------------------- |
| id          | Unique doc identifier                 |
| name        | Doc title                             |
| owner       | Email of the doc owner                |
| ownerName   | Display name of the owner             |
| createdAt   | Timestamp when the doc was created    |
| updatedAt   | Timestamp of the last update          |
| browserLink | URL to open the doc                   |
| isStarred   | Whether the doc is starred            |
| isPublished | Whether the doc is publicly published |
| folderId    | ID of the folder the doc belongs to   |

## Pages

#### Available fields

| Field       | Description                                |
| ----------- | ------------------------------------------ |
| id          | Unique page identifier                     |
| name        | Page title                                 |
| isHidden    | Whether the page is hidden from navigation |
| contentType | Type of content (canvas, sync table, etc.) |
| browserLink | URL to open the page                       |
| updatedAt   | Timestamp of the last update               |

## Tables

#### Available fields

| Field       | Description                             |
| ----------- | --------------------------------------- |
| id          | Unique table identifier                 |
| name        | Table name                              |
| tableType   | Type of table (table, view, sync table) |
| rowCount    | Number of rows in the table             |
| createdAt   | Timestamp when the table was created    |
| updatedAt   | Timestamp of the last update            |
| browserLink | URL to open the table                   |

## Rows

#### Available fields

| Field       | Description                                      |
| ----------- | ------------------------------------------------ |
| id          | Unique row identifier                            |
| name        | Row name (usually the value of the first column) |
| index       | Row position in the table                        |
| createdAt   | Timestamp when the row was created               |
| updatedAt   | Timestamp of the last update                     |
| browserLink | URL to open the row                              |
| values      | Key-value pairs of all column values for the row |

{% hint style="info" %}
Column values in the **Rows** entity are returned under the `values` field as a nested object. Depending on your destination, you may need to use Coupler.io's column mapping or transformations to flatten these into individual columns.
{% endhint %}

## Permissions

#### Available fields

| Field     | Description                              |
| --------- | ---------------------------------------- |
| id        | Permission entry identifier              |
| principal | The user or group receiving access       |
| access    | Access level (editor, commenter, viewer) |

## Common field combinations

* **Rows + Tables** — join table metadata with row data to know which table each row belongs to
* **Docs + Permissions** — combine to audit which users have access to which docs
* **Pages + Docs** — append page lists across multiple docs to build a full workspace sitemap

## Use cases by role

{% tabs %}
{% tab title="Operations" %}

* Export Coda project trackers to Google Sheets for stakeholder reporting
* Use the Rows entity to pull task or ticket data into BigQuery for trend analysis
* Monitor doc ownership and permissions with the Docs + Permissions entities
  {% endtab %}

{% tab title="Analysts" %}

* Pull structured table data from Coda into Looker Studio to build live dashboards
* Use Aggregate transformation to summarize row counts, statuses, or categories across multiple tables
* Join Rows data with external sources (e.g., CRM or marketing data) in Coupler.io before sending to BigQuery
  {% endtab %}

{% tab title="AI workflows" %}

* Route Coda table data directly to ChatGPT, Claude, or Gemini for summarization or categorization
* Feed Coda doc and page metadata to Perplexity or OpenClaw for workspace-level Q\&A
* Use Cursor with Coda row exports to generate code or automation scripts based on structured data
  {% endtab %}
  {% endtabs %}

## Platform-specific notes

* The **Rows** entity requires you to specify a doc ID and table ID — make sure you have these ready before setting up the data flow
* Coda's API returns row values as nested objects; column names in the export correspond to column IDs, not display names in some cases
* Sync tables in Coda (tables that pull data from external sources) are included in the **Tables** entity but row data availability depends on the sync status
* Very large tables (tens of thousands of rows) may take longer to sync due to Coda API rate limits

## Coda common issues

### Connection issues

<details>

<summary>Invalid API key error when connecting</summary>

Double-check that you copied the full API key from **Coda Account settings → API settings**. API keys in Coda start with `4a6f...` and are long strings — partial copies are a common cause of auth failures. Also confirm that the key hasn't been revoked or regenerated since you last used it.

</details>

<details>

<summary>Connection succeeds but no data appears</summary>

This usually means the API key belongs to a Coda account that doesn't own or have access to the docs you're trying to pull. Make sure the API key is from the account that has read access to the relevant docs and tables.

</details>

### Missing data

<details>

<summary>Rows entity returns no results</summary>

The Rows entity requires a specific doc ID and table ID. If either is missing or incorrect, the sync will return empty. Verify both IDs in the Coda URL — the doc ID appears after `/d/` and the table ID after `#` in the browser address bar.

</details>

<details>

<summary>Some columns are missing from the Rows export</summary>

Coda returns row values as nested key-value pairs using column IDs, not display names. If certain columns aren't appearing, check whether those columns exist in the specific table view you're syncing — hidden columns in a view may not be returned by the API.

</details>

<details>

<summary>Sync tables show up in Tables entity but have no rows</summary>

Sync tables in Coda pull data from external sources and may not always be fully populated. If the external sync hasn't run recently in Coda, the rows won't be available via the API either. Trigger a sync refresh in Coda first, then re-run your Coupler.io data flow.

</details>

### Permission errors

<details>

<summary>403 Forbidden when accessing a specific doc</summary>

The API key you're using belongs to a user who doesn't have access to that doc. In Coda, access is per-doc — being an admin on one doc doesn't grant access to others. Ask the doc owner to share it with your account, then re-run the data flow.

</details>

### Data discrepancies

<details>

<summary>Row counts in Coupler.io don't match what I see in Coda</summary>

Coda may return paginated results and very large tables can be truncated if API rate limits are hit during a sync. Check whether filtered views are being used — the Rows entity respects the default view, which may exclude some rows. Try syncing from the source table rather than a filtered view.

</details>

### Rate limits

<details>

<summary>Sync fails or times out on large tables</summary>

Coda's API has rate limits that can slow down or interrupt syncs for tables with thousands of rows. If you're hitting this consistently, try splitting large tables into multiple data flows or scheduling syncs during off-peak hours to reduce the chance of collisions with other API activity.

</details>

## Coda FAQ

<details>

<summary>Where do I find my Coda API key?</summary>

Go to [coda.io/account](https://coda.io/account) and scroll to **API settings**. Click **Generate API token**, give it a name, and copy the token. Paste it into the API key field when setting up your Coda data flow in Coupler.io.

</details>

<details>

<summary>How do I find the doc ID and table ID I need for the Rows entity?</summary>

Open the Coda doc in your browser. The doc ID is the alphanumeric string after `/d/` in the URL. The table ID appears after the `#` symbol. You can also run a **Tables** data flow first — it returns all table IDs and names for a given doc, making it easy to find the right one.

</details>

<details>

<summary>Can I pull data from multiple Coda docs in one data flow?</summary>

Yes. You can add multiple sources to a single data flow in Coupler.io — each pointing to a different doc or table. Use the **Append** transformation to stack the results into one dataset, or **Join** to combine them on a shared key.

</details>

<details>

<summary>Why do my column names look like IDs instead of the names I set in Coda?</summary>

Coda's API returns column identifiers in some cases rather than display names. This is a known behavior of the Coda API. You can rename columns in Coupler.io using column mapping, or rename them directly in your destination after the first sync.

</details>

<details>

<summary>Can I send Coda data to an AI tool like ChatGPT or Claude?</summary>

Yes. When setting up your data flow, select an AI destination instead of a spreadsheet or database. Coupler.io supports ChatGPT, Claude, Gemini, Perplexity, Cursor, and OpenClaw. This is useful for summarizing Coda table data, generating reports, or asking questions about your structured data.

</details>

<details>

<summary>Does Coupler.io support Coda views, or only base tables?</summary>

The Rows entity pulls from the table or view you specify by ID. This means you can target a filtered or sorted view if you want a subset of rows. Keep in mind that hidden columns in a view may not be returned — use the base table ID if you need all columns.

</details>

<details>

<summary>What happens if my Coda API key is rotated or deleted?</summary>

All data flows using that key will fail immediately. To fix this, generate a new API key in Coda and update the connection in Coupler.io. To avoid widespread disruption, use a dedicated API key for Coupler.io so rotating it only affects this integration.

</details>

{% hint style="info" %}
For details on what fields are available for each entity, see [Data Overview](#coda-data-overview). For help with sync errors, visit [Common Issues](#coda-common-issues). For setup recommendations, check [Best Practices](https://docs.coupler.io/sources/category/files-and-tables/coda/best-practices.md).
{% endhint %}


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.coupler.io/sources/category/files-and-tables/coda.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
