Skip to main content

Using the Coda MCP

The Coda MCP (Model Context Protocol) is a connection layer that enables AI tools - like Cursor, Claude, etc. - to read and write to your Coda docs using plain-language prompts. Instead of clicking through the Coda UI, you describe what you want in a chat window, and the AI carries it out directly in your doc. Think of it as giving an AI assistant the same access to your Coda workspace that you have, and letting it act on your behalf based on your instructions.
 
This article will cover the basics of using the Coda MCP, including general best practices, as well as some specific examples to spark inspiration.

💡 Haven't connected to the Coda MCP yet? Get started with this article.

Please note: The Coda MCP is in beta. Behavior and available tools are subject to change.


Within this article, you’ll find...

 

Coda MCP tools

The Coda MCP has access to a wide array of abilities in Coda. Most of the actions you can do yourself within a doc can also be performed via the MCP. This includes...
  • Creating, deleting, and searching docs
  • Creating, deleting, updating, and reading pages - with access to a variety of building blocks including callouts, codeblocks, grids, and more
  • Creating tables, adding and modifying rows, adding and modifying columns, configuring views, and deleting table content
  • Writing and executing formulas
  • Creating and triggering controls and buttons
For a comprehensive, up-to-date list of the Coda MCP tools, please refer to this documentation.
 
 
 
 

Best practices

The table below contains some tips and patterns for getting the most out of Coda MCP. These practices help you write better prompts, work more efficiently, and avoid pitfalls.
 

Providing context

Best Practice Details
Provide the Coda URL

When you want to work with a specific doc, page, table, or row— share the Coda URL directly as a part of your prompt. The agent will use url_decode  to extract the IDs it needs.

This is more reliable than describing what you're looking for and forcing the agent to search for it, which uses many more tokens.
Use screenshots and files for ingesting external data
When data lives outside Coda (Amazon orders, emails, PDFs), take a screenshot or export to CSV/markdown. The LLM can parse it, then use Coda MCP to add it to your docs. This is great for one-time imports.
Chaining AI tools and capabilities to pass in context
Different tools offer different capabilities:
  • Web-based portals like ChatGPT and Claude Web are the most flexible when working with varying types of files (Eg. PDF, Markdown, CSV, etc)
  • CLI tools are best for working with Coda
  • Cursor is the best for working with MCPs
If you have existing subscriptions you can leverage across these tools, you can chain them and pass context between them using Markdown.
 
Example: if you’re working with Coda MCP in Cursor but need to parse a PDF, you can start in ChatGPT to convert your PDF → Markdown and then provide the Markdown file to Cursor to turn it into a Coda doc.

 

Accuracy and efficiency

Best Practice Details
Turn off unnecessary MCPs
It’s common to use many MCPs in your environment. For example, you may have Coda, Atlassian, and Figma MCPs setup in your AI tool. However, the more MCPs and tools you make available to your agent, the less context it will have to pick from, and the less accurate it will be at performing tasks.
 
As a result, it is strongly advised to enable only the MCPs you need at that moment. You can always turn them back on when you need them.
Use local CSV and MD files for very large datasets
When working with very large amounts of data (multiple large pages, huge tables), use markdown and CSV files to store intermediate work locally with Cursor, Codex or Claude Code.
 
For example, if you’re analyzing a Coda table with 1000s of cells, store your analysis locally in a CSV or Markdown file while you are iterating. Once you are ready, you can upload it to Coda.
 
Tip: Sometimes, it is faster and cheaper to upload using Coda’s native Markdown and CSV importers rather than using MCP at this stage, as it saves AI tokens and works faster for deterministic imports.
Be selective with content to include
The ReadPage tool supports a param called ContentTypesToInclude, which can be helpful for loading different amounts of context.
 
• Just exploring structure? → ["tables"]
• Need to edit content? → ["pageContentRich"]
• Just reading for context? → ["pageContentMarkdown"]
 

Requesting everything increases response time and token usage. So you can prompt the agent with something like “Read tables on this page” or “Read comments on this page” and it will automatically select the right options.
 
Additionally, you can specify which columns or rows you’d like to use when Reading large tables.

 

Prompting

Best Practice Details
Describe the end result, not the steps
"I want a meeting notes page with sections for attendees, agenda, action items, and decisions" works better than step-by-step instructions about which tools to call.
 
Describe what you’re looking for with precise boundaries and good details. Then let the agent figure out how to build it.
Tell it your goal, not just the task
 "I'm preparing for a board meeting next week" gives context that helps the agent make better decisions about structure, formatting, and what to include.
Specify the scope and boundaries
"Only update the Marketing section, don't touch Engineering" prevents unintended changes. Being explicit about boundaries helps avoid surprises. Similarly, you can tell your agent to only look at a specific page, doc, table or row.
Provide examples when adding data
 "Add 5 tasks like: 'Review Q3 metrics - Due Friday - Assigned to Sarah'" gives the agent a pattern to follow. One good example is worth a paragraph of explanation.
Name things clearly in prompts
Use the actual names of your pages, tables, and columns so the agent can find them easily. "Update the Projects table" is better than "update that table I made last week".
 
See the related “Provide the Coda URL” tip above.
Be specific about what you want changed
Instead of "update my doc", say "add a row to the Projects table with name 'Q4 Launch' and status 'In Progress'".
 
The more specific you are, the fewer back-and-forth clarifications you'll need. You can use URLs to tell the agent what to look at, and you can reference specific pages, tables and rows. See the “Provide the Coda URL” tip above.
Reference existing content as examples
"Make the new page look like my 'Weekly Standup Template'" or "Use the same columns as my Tasks table" helps the agent match your existing style and structure.

You can also look at the “Personalize with rules files that read Coda” tip below for a more structured approach.
Note: we are currently improving how the MCP works with templates so this will get smoother over time.

 

Workflow

Best Practice Details
Request a preview on big changes
"What would this look like?" or "Summarize what you're about to do" before executing.
 
Especially useful for restructuring, bulk updates, or anything you can't easily undo.
Ask questions before making large changes
 "What tables are in this doc?" or "Show me the structure of this page" before jumping to edits. This helps you understand what you're working with and catch potential issues early.
Personalize with rules files that read Coda
Set up Cursor Rules, Claude.md, or Agents.md to give the agent context about your preferences, common doc structures, or naming conventions. 

Tip: You can add something like “Read this page <PageURL> first before answering any questions” and use your coda page to specify shortcuts, templates you like to use, prompt banks, and many other preferences. 
Ask for alternatives to confirm the approach
Try saying "give me 3 different ways to organize this information" when you're not sure what structure you want. The agent can propose options for you to choose from.
Customize your tool permissions to stop it asking you each time
If you don’t want the agent to ask permission for every tool call in the MCP, you can choose to use an Allowlist or Run everything inside of Claude Code, Cursor, Codex, etc.

 

Building your own agent

Best Practice Details
Let the agent choose tools to call, don’t name them in Code
Don't call tools directly in your prompts. This is especially relevant if you are building your own custom agents with the MCP. There are two problems with calling tools directly:
  • Tool names and parameters are not fixed and may change while the MCP is in beta. Relying on these will  make your prompts and agents brittle
  • Agents can often choose more efficient paths for multi-tool workflows on their own

 

 

Example use cases

Starter examples:

Transform bullets into polished writeup

Take rough bullet points, brainstorm notes, or quick thoughts and transform them into professional, well-structured documents complete with narrative flow, proper headings, tables for data, and callouts for important information. Perfect for turning meeting notes into PRDs or ideas into proposals.
 
Example workflow:
1) Paste or type bullet points into Coda page
2) Ask AI to expand into full write-up with specific tone/structure
3) AI generates complete document with headings, paragraphs, tables, and callouts
4) Review and refine as needed
 

Create and populate tables from scratch

Build complete database tables from natural language descriptions or raw data. AI can design appropriate column structures, choose correct data types and formats, then populate rows with data from various sources (text descriptions, CSV data, web research, or document analysis).
 
Example workflow:
1) Describe table needed (e.g., 'Create a feature request tracker with columns for title, description, priority, owner, status')
2) AI creates table with appropriate column types
3) Provide data sources or ask AI to populate
4) AI fills table with structured data, applying correct formats
 

Search and extract insights from data

Perform intelligent analysis across pages and tables to find patterns, trends, and insights. Ask questions in natural language like 'What are the top customer complaints?' or 'Which features are most requested?' and AI searches through your data, aggregates findings, and presents insights with supporting evidence.
 
Example workflow:
  1. Provide a Coda URL to your AI tool
  2. Ask it questions about the data
Note: When working with large amounts of data, your AI tool can run out of context. See the Best Practices section above for how to handle this.
 

Structure unorganized meeting notes

Transform rambling meeting transcripts or rough notes into organized, actionable documents. AI extracts key decisions, action items, discussion topics, and attendee contributions, then structures them into clean documents with sections for overview, decisions made, action items table, and next steps.
 
Example workflow:
1) Paste meeting transcript or notes into Coda
2) Ask AI to structure into organized document
3) AI creates sections for summary, decisions, action items, discussion points
4) Generates action items table with owners and deadlines
5) Adds relevant callouts for important decisions
 
 
 

Intermediate examples:

Generate write-ups from your codebase

Automatically create comprehensive documentation, technical specs, or code explanations by analyzing your codebase. The AI reads through code files, understands structure and relationships, then generates polished documentation in Coda with proper formatting, code blocks, and explanations.
 
Example workflow:
  1. Point AI to GitHub repo or local codebase
  2. Specify what to document (API endpoints, architecture, specific modules)
  3. AI analyzes code and generates structured write-up
  4. Content is written directly to Coda page with proper formatting, tables for API specs, and code examples

Create a weekly update summary

Take a table of project updates and ask AI to generate a shareable summary for you. You can let it know how to format it based on where you’d like to share it (eg. in Slack or via Email).
 
Example workflow:
  1. Ask AI to read your table and filter to relevant updates
  2. Let it know how you want to format the message, how notes should be grouped, how blank values should be handled, etc.
  3. Once the method works, ask AI to create a reusable prompt for you and save it in a Coda doc for reuse!

Centralized feedback and comments review

Use AI to aggregate, summarize, and organize all comments and feedback on your documents in one place. AI can read through comment threads, extract key themes, categorize feedback by topic, and create summary tables showing what needs attention, who commented, and priority levels. This is a great follow-up to the “Generate write-ups from your codebase” example above.
 
Example workflow:
  1. AI reads page with comments
  2. Extracts and categorizes all feedback
  3. Creates summary table with comment text, author, topic, priority
  4. Generates action items or response plan based on feedback themes
     
 

Advanced examples:

Batch content updates and migrations

Perform large-scale content transformations across multiple pages or tables. Update formatting, migrate content structures, apply consistent styling, rename fields, or transform data formats across hundreds of rows or multiple documents. Essential for content migrations, rebranding, or structural changes.
 
Example workflow:
  1. Define transformation rules (e.g., 'Update all status fields from old values to new taxonomy')
  2. AI reads current state using pagination
  3. Processes changes in batches to respect limits
  4. Updates content with new structure/values
  5. Provides summary of changes made

Build prompt libraries and instruction sets

Create and maintain organized libraries of prompts, instructions, and guidelines for AI agents. Structure best practices, prompt templates, and reusable instruction sets in searchable tables. Perfect for teams standardizing their AI workflows or building custom agents that need consistent instructions.
 
Example workflow:
  1. Create table structure for prompts (category, use case, prompt text, variables, example output)
  2. AI helps refine and categorize prompts
  3. Build library of tested, effective prompts
  4. Add “shortcuts” or rules into the table for when a prompt should get triggered
  5. Use Cursor Rules, Agent.MD, Claude.MD files to tell your agents to read the prompt library first and use those prompts when appropriate
     

💡 Ready to dive even deeper into the Coda MCP? Check out these helpful guides:

 

FAQs

Does my role in Coda affect what I can do with the MCP?

Yes, your role does affect how you can use the Coda MCP.

If you’re a Doc Maker (in a paid workspace) you will have full access to the Coda MCP and its tools and endpoints. While some rate limits will apply, these are intended only to preserve the performance of our MCP and should not interfere with reasonable usage.
 
If you are an editor, you will have access to a “free taste” of the Coda MCP, with a limit of 30 requests per week (with a max of 60 per month). During this “free taste,” you can utilize any of the “read” type tools. In other words, you will not be able to use the MCP to take Doc Maker actions. Once you exceed these limits, you will lose access to the MCP and will need to upgrade your role to continue using.
How does pricing work for the Coda MCP?
Access to the Coda MCP is included for all Doc Makers on paid Coda plans. While rate limits do apply, these limits are high and should not interfere with reasonable usage of the MCP.
 
Editors and members of Free Coda plans will also have access to a limited “free taste” of the Coda MCP (up to 30 requests per week, with a max of 60 requests per month). Note that editors will only be able to use the “read” level tools. Once these limits have been exceeded, you will need to upgrade to a paid Doc Maker role in order to continue using the MCP.
What actions or tools does the MCP have access to?

You can find the full list of Coda MCP tools and endpoints here.

How do I submit bugs or feedback for the MCP?

Please submit any bugs or feedback via this form. Thank you in advance!

 

 

 

Related resources