September 4
TL;DR:If you need to connect your meeting notes to AI tools like Claude or ChatGPT, choose the protocol built for LLMs rather than building custom code. Traditional REST APIs typically require significant engineering time to create and maintain rigid data pipelines. The Model Context Protocol (MCP) lets your AI tools query your Granola notes dynamically with minimal configuration overhead, and you can be up and running in under five minutes. APIs are particularly well-suited for high-volume, structured data syncing between databases and non-AI consumers. For qualitative context from customer conversations, MCP is the lowest-friction path: no custom code, no copy-pasting, and a privacy-first architecture that doesn't store meeting audio, encrypts notes in transit and at rest, and authenticates via OAuth with no API keys required.
Most product teams carry months of customer research that never gets properly synthesized because it lives in static documents, scattered Notion pages, and personal notes. When you want your AI assistant to analyze past interviews, the options are usually: copy-paste transcripts manually, or wait weeks for engineering to build a custom API integration. Neither option fits anyone who needs answers from their meeting archive before a planning session, a pitch, or a hiring decision, without waiting on an engineer to build the plumbing first.
Granola is the AI notepad for people in back-to-back meetings. You jot rough notes during calls, and we enhance them with AI-powered context from your transcript. The Model Context Protocol changes the integration calculus by letting AI tools query your notes dynamically. This guide explains the architectural differences between MCP and traditional APIs, helping you choose the right path for your research workflows.
How APIs connect your software tools #
Application Programming Interfaces (APIs) have been the standard method for connecting software applications for decades. A REST API (Representational State Transfer) follows the HTTP request-response model: a client sends a request to a specific URL endpoint, the server processes it, and returns a structured JSON response. REST uses HTTP verbs: GET to read data, POST to create it, PUT to update it, and DELETE to remove it. These verbs give developers a predictable, well-documented way to move data between systems.
The critical characteristic of REST is that it is stateless. Each request contains all the information the server needs to respond, with no memory of previous requests. That makes APIs reliable for machine-to-machine communication, but it also means developers must explicitly define every data path and query in advance. Nothing is discovered dynamically. Everything is written, tested, and maintained by hand.
Common API workflows for product teams
For product teams, common API workflows include pushing meeting summaries to HubSpot, triggering action items in project tools after planning sessions, and running nightly batch jobs that move structured meeting data into analytics dashboards.
Practical API integration examples
APIs excel at predictable, trigger-based data movement. Granola's API is available on Business and Enterprise plans. You can use it to:
- Sync structured meeting summaries to your CRM on a nightly schedule
- Push action items to project management tools when specific meetings end
- Feed raw transcript data into a data warehouse for analytics queries
These workflows are valuable, but they all share one constraint: every query and every data path must be defined in advance by an engineer. When the question changes, the code changes too.
Defining the Model Context Protocol #
The Model Context Protocol is an open standard introduced in November 2024 to solve a specific problem: how do AI assistants connect to the systems where data lives without requiring developers to build custom connectors for every combination of tool and data source?
Think of it like a research assistant who can look through your filing cabinet on demand. With a traditional API, you have to mail that assistant specific folders one by one, deciding in advance exactly which folders they need. With MCP, the assistant opens the cabinet themselves, scans the labels, and pulls whatever is relevant to your question.
The MCP specification describes three capability types: Tools (actions the AI decides to take), Resources (context provided to the AI), and Prompts (user-invoked interactions). This structure enables dynamic discovery rather than rigid endpoint mapping. MCP was designed to solve what practitioners call the M×N integration problem: if you have M AI models and N data sources, a traditional approach requires M×N custom connectors. MCP collapses that to M+N, meaning one server exposes data to every compatible AI client simultaneously.
How MCP handles queries at runtime
MCP refines how AI agents access context. Instead of a developer writing custom code to define every query, MCP allows the AI model itself to discover what tools and resources are available at runtime, then construct and execute queries using natural language. The model decides what to retrieve based on what you ask. You are not locked into the queries someone else anticipated when they wrote the integration.
MCP is stateless like REST: every request carries the protocol version and the relevant capabilities independently. The difference is that those capabilities are discovered dynamically at runtime rather than hard-coded by a developer in advance. The difference is not cosmetic. It determines who bears the integration burden: engineering teams or the AI itself.
Understanding MCP connector roles
Three roles define every MCP architecture:
The host: The AI application that initiates queries. Claude Desktop, ChatGPT, and Cursor are all hosts.The client: The protocol layer inside the host that manages the connection and handles capability negotiation.The server: The data source that exposes specific tools and resources. We built Granola to serve as the MCP server, exposing tools likequery_granola_meetings
,list_meeting_folders
,list_meetings
,get_meetings
,get_meeting_transcript
, andget_account_info
.
Once you configure the connection, our Granola MCP connector allows any compatible AI tool to search your meeting history, extract action items, find specific topics from past conversations, and browse meeting folders without writing a single line of code.
Key differences: MCP versus API for note capture #
When you are deciding whether to build an API integration or enable an MCP connection for your customer research notes, the practical gap is significant enough to determine whether your team actually uses the capability at all.
The contrast in setup time alone reshapes who can do it. Custom REST integrations often take weeks of engineering development to reach a well-tested, production-ready build. Our MCP connector requires under five minutes: authenticate via OAuth, add a short config to your AI tool, and your meeting history is queryable immediately.
| Feature | Traditional REST API | Model Context Protocol (MCP) |
|---|---|---|
| Setup time | Weeks of engineering development (scoping, building, and testing) | Under 5 minutes (authenticate and configure) |
| Required skills | Software engineering (Python, Node.js, API keys) | Zero coding (first-party app connection) |
| Integration method | Custom code for specific endpoints | Dynamic runtime discovery by the AI model |
| Schema definition | Static via OpenAPI/Swagger at compile time | Dynamic JSON Schema discovered at runtime |
| Primary use case | Structured, high-volume data syncing | Dynamic, context-aware queries for LLMs |
For a research-focused product team without dedicated engineering support, this table tells the real story. A custom API integration requires developer time that is almost never available when insights are needed before a planning review.
Ongoing upkeep for MCP versus API
APIs also accumulate maintenance debt over time. Versioning cycles introduce breaking changes. Deprecated fields require client rewrites. Authentication tokens expire and need refreshing. Each of these events requires developer attention, often weeks after the original integration was built.
MCP shifts this burden to dynamic discovery. When the server updates its capabilities, connected AI tools pick them up automatically at runtime. The server tells the client what tools are available at that moment, rather than relying on documentation written months earlier. When we add new capabilities to Granola's MCP server, your Claude or Cursor instance sees them the next time it connects, with no code changes on your end.
When to use MCP or API
The right choice depends on what you are trying to do and who is doing it.
Choose REST APIs when:
- You are syncing structured data between systems on a fixed schedule (nightly CRM updates, data warehouse loads).
- The consumers are applications rather than AI models (mobile apps, dashboards, legacy systems).
- You need high-throughput, deterministic output at machine speed.
Choose MCP when:
- You need to ask open-ended questions across unstructured qualitative data.
- You want multiple AI tools to access the same data without building multiple integrations.
- Engineering resources are not available for a custom build.
- Data needs to stay local for security or compliance reasons.
Why prioritize MCP for your note workflows #
The specific value of MCP for meeting-heavy workflows lies in what it makes possible without engineering overhead: ad-hoc synthesis across months of conversations, without copy-pasting, without waiting for a developer to build a custom integration, and without leaving your AI tool.
Instead of exporting a transcript, opening Claude, pasting the text, and typing your question, MCP collapses that to a single prompt. Ask Claude: "What did users say about the new navigation design?" and it queries Granola directly, retrieves the relevant meeting segments, and synthesizes findings with source citations. Our AI-enhanced notes combine your rough notes with real-time transcription context, so we structure the data our MCP server exposes around your priorities rather than generating a generic summary.
The same pattern applies to cross-interview synthesis. With every call in one place, you can ask "Which UX issues come up most often?" and get source-linked citations from specific conversations rather than reviewing dozens of individual documents.
Granola's MCP tools and what they expose
MCP is available on every Granola plan, including Basic. Basic plan users can query the last 30 days of meeting data. Full history and transcript access are available on paid plans.
We expose Granola as an MCP server, providing these tools to Claude, ChatGPT, and Cursor once you connect:
query_granola_meetings
: Search for specific topics, decisions, or discussions across past meetings using natural language.get_meetings
: Retrieve notes, attendees, dates, and summarized content for specific meetings.list_meetings
: Browse available meetings by date, title, and attendees before retrieving full content.get_meeting_transcript
: Access raw transcripts for exact quotes (paid plans).list_meeting_folders
: Browse accessible folders by title and note count (paid plans).get_account_info
: Verify which Granola account and workspace is active.
When to prioritize MCP over APIs
MCP is the clear choice when you need to query unstructured text across multiple meetings at once, when you do not have engineering resources to build a custom integration, or when you want more than one AI tool reading from the same research archive without maintaining separate connectors for each.
Architectural comparison: MCP versus REST #
For teams who need to present the technical distinctions to a security or engineering team before moving forward, this table covers the key architectural dimensions.
| Architectural dimension | Traditional REST API | Model Context Protocol (MCP) |
|---|---|---|
| Transport layer | Sends data over the internet using standard web protocols | AI tool connects to Granola's hosted MCP server (mcp.granola.ai) over Streamable HTTP, authenticated via OAuth with no API keys required. Notes are encrypted in transit and at rest |
| Schema definition | Fixed data structure defined by developers before the integration is deployed | Data structure discovered automatically each time the AI connects |
| State management | No memory between requests. Each call is independent | Stateless like REST, but capabilities are discovered dynamically per connection rather than hard-coded |
| Data access model | Retrieves or sends data through fixed addresses a developer defines in advance | AI model selects and runs the appropriate tool based on your question |
| Discovery | Manual documentation reading | Automatic tool discovery by the AI model |
The security properties of Granola's MCP implementation come from its authentication model, not local routing. OAuth scopes access to your account only, no API keys are stored or shared, and all data in transit is encrypted. That matters when transcripts contain sensitive participant feedback about competitors, internal processes, or unreleased roadmap decisions.
That said, APIs outperform MCP in specific scenarios. For massive datasets spanning thousands of meetings or millions of customer records, pushing raw data via API to a structured database and querying it directly is more efficient than attempting to pass everything through an LLM's context window. If analysts will query your data with SQL rather than natural language, REST remains the practical choice for those workflows.
MCP, APIs, and automation tools #
Our Granola and Zapier integration handles linear triggers: a meeting ends, a summary posts to a Slack channel, action items create a Notion page. These workflows are predictable and valuable, but Zapier's trigger-based workflows are not designed for open-ended reasoning across multiple documents.
When to use MCP versus Zapier
Use Zapier when the task is linear and predictable: post a summary to Slack when a meeting ends, or update a HubSpot contact record after a customer call. Zapier moves data from point A to point B reliably and without engineering effort.
Use MCP when the question is open-ended: "Based on my last ten customer interviews, what are the top three usability issues?" That requires reasoning across multiple documents simultaneously, not a trigger-action workflow.
The two can also coexist with our API. A common setup: use the Granola API to push structured summaries to HubSpot nightly, and use the MCP connector to run qualitative analysis in Claude across the same meeting data. Both access Granola's data through different interfaces for different jobs, which means you do not have to choose one path exclusively.
Security and compliance #
Customer research transcripts are sensitive. Participants share candid feedback under an assumption of discretion, and the architecture of how you connect those transcripts to AI tools matters for participant trust and your compliance obligations.
Granola doesn't store meeting audio. It transcribes in real time and the audio is not retained. Transcripts are stored in a US-hosted AWS Virtual Private Cloud, and SOC 2 Type 2 certification, completed in July 2025, confirms that independent auditors verified these controls operate effectively over a sustained period rather than at a single point in time.
When your AI tool connects via MCP, it authenticates to Granola's hosted MCP server at mcp.granola.ai using OAuth. No API keys are created or shared. Access is scoped to your account, and all data is encrypted in transit and at rest.
Our transparency features and consent guide provide additional tools for managing participant notification in research sessions.
When presenting MCP integration to your security team, use this compliance checklist to demonstrate that our local-first architecture protects participant trust:
- Meeting audio is not stored. Granola transcribes in real time and does not retain audio (notes and transcripts stored in Granola's US-hosted AWS Virtual Private Cloud)
- SOC 2 Type 2 certified architecture (July 2025)
- Scoped folder access (choose which folders the MCP client can read)
- Third-party AI providers are contractually prohibited from training on your data. Granola's own training uses anonymized data, with opt-out available in Settings on every plan and off by default for Enterprise.
- GDPR compliant data handling
- Note for Enterprise teams: MCP is turned off by default on Enterprise plans and must be enabled by an admin in Granola settings.
Try Granola for free: download the Mac or Windows app, connect your calendar, and capture your next customer interview. Once your first notes are in, follow our Granola MCP documentation to connect your meeting history to Claude, ChatGPT, or Cursor and start asking questions across your research archive without copy-pasting a single line.
FAQs #
Is MCP just a fancy API?
No. MCP is a protocol layer that abstracts APIs rather than replacing them. Traditional APIs require a developer to write explicit code defining exactly which data fields to retrieve and how to format them for an LLM. MCP allows an AI model to dynamically discover what data is available at runtime and query it using natural language, with no custom integration code required on the AI side. For anyone querying their meeting archive, whether customer interviews, candidate calls, board meetings, or sales reviews, this means you can connect your notes to Claude without waiting for engineering time. Most MCP servers do call REST APIs internally to fetch data, but they present that data to the model in a standardized, dynamically discoverable format that removes the engineering burden from the consuming application.
How long does it take to set up Granola's MCP connector?
Under five minutes. You authenticate via OAuth in our settings, add a short configuration to your AI tool of choice, and your meeting history becomes queryable immediately. We built our Granola MCP connector to work with Claude Desktop, ChatGPT, and Cursor without requiring coding or command-line work. MCP is available on every Granola plan, including Basic.
What is the difference between using Zapier and using MCP with Granola?
Zapier is best for linear, trigger-action workflows: when a meeting ends, post the summary to Slack or create a Notion page. MCP is best for open-ended qualitative reasoning, where you ask your AI assistant to analyze patterns across your last quarter of customer interviews. Zapier moves data along a fixed path. MCP lets the AI model decide what data to retrieve based on the question you ask.
Can I use both MCP and APIs with Granola?
Yes. We built both to serve different workflows. Use our API to push structured summaries to your CRM nightly, and use our MCP connector to run qualitative analysis in Claude across the same meeting data. Both access your notes through different interfaces for different jobs, so your structured and conversational workflows can run in parallel from a single source of truth.
Key terms glossary #
REST API (Representational State Transfer): A software interface that lets applications exchange data over HTTP using fixed endpoints and explicit request types. Every query must be defined in advance by a developer.
Model Context Protocol (MCP): An open standard that lets AI models dynamically discover and query data sources at runtime without requiring custom code on the consuming application side.
MCP host: The AI application initiating queries, such as Claude Desktop, ChatGPT, or Cursor.
MCP server: The data source exposing tools and resources to the host. In Granola's case, this is Granola's hosted MCP server at mcp.granola.ai, which AI tools connect to over Streamable HTTP using OAuth authentication.
Streamable HTTP transport: The communication method Granola's MCP uses, where the AI tool connects to Granola's hosted MCP server over HTTPS. Authentication is handled via OAuth with no API keys required, and all data is encrypted in transit.
Dynamic discovery: The ability of an MCP client to ask a server at runtime what tools are available, rather than relying on static documentation written in advance.
SOC 2 Type 2: An independent audit certification confirming that a company's security controls operate effectively over a sustained period, not just at a single point in time.
Folder-level query: A Granola feature allowing you to search and synthesize meeting notes within a defined folder, so research from a specific project or customer set stays organized and queryable.