The query a developer asks about any new API will not be whether or not it exists, however whether or not there may be sufficient floor to justify the combination work.
Granola’s API is a read-only REST floor, launched in February 2026, that provides programmatic entry to a workspace’s assembly notes, transcripts, and AI-generated summaries. The developer docs are public, the endpoints are named, and the speed limits are printed. For a platform that payments itself as an AI assembly notepad, transport an API indicators intent to turn out to be infrastructure, not only a desktop app.
However intent and API maturity are various things.
Granola’s API does one factor: allow you to learn assembly notes and transcripts out of Granola workspaces. In case your construct wants to tug structured assembly knowledge right into a data base, a CRM, or a customized AI workflow, the API is scoped for that job. If it is advisable write knowledge again into Granola, subscribe to real-time occasions when new conferences are captured, or entry B2B intelligence past what was mentioned in a gathering (contact enrichment, firm knowledge, intent indicators, org charts), that may be a totally different layer of the stack.
That is the place ZoomInfo enters the image. As a GTM platform, ZoomInfo provides an Enterprise API, a REST suite overlaying search, enrichment, AI intelligence, and viewers administration throughout 500M contacts and 100M corporations, with an MCP server for AI-agent workflows. The place Granola’s API surfaces what was mentioned, ZoomInfo’s API surfaces who mentioned it, what corporations they signify, and whether or not these accounts are price pursuing.
This overview covers the Granola API in technical depth first (authentication, endpoints, price limits, and pricing), then evaluations ZoomInfo’s API because the intelligence layer that picks up the place assembly context stops.
Granola API at a Look
|
Attribute |
Element |
|---|---|
|
API kind |
REST over HTTPS, JSON responses |
|
Authentication |
Bearer token (API key prefixed with grn_) |
|
Base URL |
https://public-api.granola.ai |
|
Present model |
v1.2.0 (Might 2026) |
|
Charge limits |
25-request burst / 5 requests per second sustained (300 requests/minute) |
|
SDKs |
None; cURL examples solely |
|
Webhooks |
Not supported |
|
Documentation |
docs.granola.ai/introduction (Mintlify-hosted) |
|
Pricing / entry |
Included on Enterprise ($14/consumer/month) and Enterprise ($35/consumer/month) plans; not accessible on the free tier |
Granola API: What Works Effectively & What to Plan Round
|
What works effectively |
What to plan round |
|---|---|
|
Public docs with no login wall and inline cURL examples |
Learn-only: no create, replace, or delete operations |
|
Clear endpoint design with typed ID patterns and cursor pagination |
Three endpoints whole; all the floor is checklist notes, get observe, and checklist folders |
|
Transcript contains timestamps and speaker supply labels |
No webhooks or occasion streaming; polling is the one choice for brand spanking new knowledge |
|
Abstract accessible in each plain textual content and markdown codecs |
No official SDKs in any language |
|
Enterprise admins can scope API key entry (private vs. public notes) |
Pagination capped at 30 gadgets per web page |
|
Calendar occasion metadata and attendee knowledge included in observe responses |
Notes with out a accomplished AI abstract are excluded from all responses |
Granola API: Authentication & Getting Began
API entry is on the market to any workspace member on a Enterprise or Enterprise plan. There isn’t a separate developer signup, no approval gate, and no enterprise-only restriction past the plan tier. The free (Fundamental) plan doesn’t embrace API entry.
Keys are created contained in the Granola desktop app at Settings > Connectors > API keys. Throughout creation, the consumer selects a number of entry scopes:
-
Private notes: notes the consumer owns, notes shared with them, and notes in personal folders shared with them
On Enterprise plans, workspace admins may management permitted API scopes through Settings > Workspace > Basic > API entry for members. Keys might be edited after creation to vary scopes or revoked completely.
Authentication is easy. Each request contains an Authorization: Bearer
curl “https://public-api.granola.ai/v1/notes?page_size=5”
-H “Authorization: Bearer grn_YOUR_API_KEY”
There isn’t a OAuth stream, no token change, and no rotating credentials. The simplicity is a tradeoff: Bearer token auth is straightforward to implement however provides no delegated entry mannequin. If you’re constructing a multi-tenant integration the place every buyer authenticates with their very own Granola workspace, every buyer should generate and share an API key manually.
One constraint price noting: the MCP connector makes use of browser-based OAuth quite than API keys, and Granola recommends it for AI assistant integrations (Claude, ChatGPT, Cursor, and others). In case your integration goal is an MCP-compatible instrument, the MCP route bypasses the API fully.
Granola API: Core Endpoints & Capabilities
The API is read-only and arranged round two sources: notes and folders. As of v1.2.0, all the endpoint floor consists of three GET operations.
Notes
The notes floor offers you entry to assembly knowledge: summaries, transcripts, attendees, and calendar metadata.
Listing Notes: GET /v1/notes
Returns a paginated checklist of accessible assembly notes. Question parameters help filtering by time vary (created_before, created_after, updated_after in ISO 8601), by folder (folder_id, validated towards the sample ^fol_[a-zA-Z0-9]{14}$), and pagination through cursor and page_size (default 10, max 30).
The response form:
{
“notes”: […],
“hasMore”: true,
“cursor”: “next_page_cursor_string”
}
Every observe within the checklist contains id, object, title, proprietor (title and e mail), created_at, and updated_at. Full content material requires a separate Get Observe name.

Supply: Granola API
Get Observe: GET /v1/notes/{note_id}
Retrieves a single observe by ID (sample: ^not_[a-zA-Z0-9]{14}$). The complete response contains:
-
title, proprietor, created_at, updated_at, web_url
-
calendar_event: occasion title, invitees, organizer, begin and finish instances
-
transcript: array of segments with speaker supply, textual content, and timestamps (should be requested through the embrace question parameter)

Supply: Granola API
The transcript format differs by platform. On macOS, the transcript is a steady change with out named speaker labels. On iPhone, speaker identification labels audio system as Speaker A, Speaker B, and so forth, which carries by way of to the API response. The API documentation contains instance response shapes for each.
What you’d construct with this: a nightly sync that pulls accomplished assembly notes right into a staff data base, a CRM pipeline that extracts motion gadgets and attendee knowledge from gross sales name summaries, or an AI agent that queries current conferences to arrange briefings.
Folders
Listing Folders: GET /v1/folders
Added in v1.1.0 (April 2026). Returns a paginated, alphabetically sorted checklist of accessible folders. Every folder contains id, object, title, and parent_folder_id for hierarchy navigation. The first use case is discovering folder_id values for filtering the Listing Notes endpoint.
What the API Does Not Cowl
The read-only scope is a deliberate design choice, however it defines a transparent boundary for what you may construct:
-
No create, replace, or delete operations on notes, folders, or every other useful resource
Granola API: SDKs, Docs & Charge Limits
SDKs & Libraries
Granola doesn’t publish official SDKs in any language. The API reference offers uncooked cURL examples solely. No JavaScript, Python, or different language-specific packages seem within the documentation. Builders combine immediately over HTTP.
For a three-endpoint, read-only API, the absence of SDKs will not be a severe barrier. The request/response shapes are easy sufficient {that a} wrapper provides little past comfort. However it indicators the place the API is in its lifecycle: 4 months outdated and nonetheless increasing.
Documentation & Developer Expertise
The API documentation lives at docs.granola.ai/introduction, constructed on Mintlify. The reference part is compact: one overview web page, three endpoint pages, and a changelog.
Every endpoint web page contains the total request/response schema, all question parameters with sorts and validation patterns (regex patterns for observe and folder IDs like ^not_[a-zA-Z0-9]{14}$), and inline cURL examples with pattern response our bodies.
The introduction web page features a quick-start walkthrough displaying the best way to checklist current notes, paginate utilizing a cursor, and fetch a selected observe with a transcript.
The changelog tracks three variations with dates and modifications:
What the docs lack: no OpenAPI/Swagger spec obtain, no Postman assortment, no sandbox surroundings, and no interactive “Strive It” explorer. For a developer evaluating the API, this implies you want an lively Granola account with a Enterprise or Enterprise plan to check something. There isn’t a option to discover the API with out committing to a paid plan first.
Charge Limits & Constraints
Charge limits are printed clearly:
|
Metric |
Worth |
|---|---|
|
Burst capability |
25 requests |
|
Time window |
5 seconds |
|
Sustained price |
5 requests/second (300 requests/minute) |
Exceeding the restrict returns 429 Too Many Requests. Two extra constraints form what you may construct:
-
Pagination ceiling: Each Listing Notes and Listing Folders cap at 30 gadgets per web page. For workspaces with hundreds of conferences, preliminary knowledge hundreds require many sequential paginated requests.
-
No unsummarized notes: The API excludes notes that haven’t accomplished AI processing. In case your pipeline is determined by capturing assembly knowledge proper after a name ends, there’s a delay between the assembly and the observe showing within the API.
The 5 req/sec sustained price is modest however ample for a read-only assembly notes API. A nightly sync pulling 500 notes would take below three minutes with cursor pagination. Polling for brand spanking new notes works however wastes requests with out webhooks to sign when new knowledge is on the market.
Granola API Pricing & Entry Prices
Granola bundles API entry into its paid subscription plans quite than charging per name or per file. The pricing web page breaks down merely:
There are not any per-call expenses, no credit score system, no overage charges, and no usage-based API pricing. Annual billing will not be at present accessible; all plans invoice month-to-month. Cancellation is allowed at any time with no penalty; the subscription stays lively by way of the tip of the present billing cycle.
For a developer sizing prices: a staff of 10 on the Marketing strategy pays $140/month whole, and each member can create API keys. The Enterprise plan at $35/consumer/month ($350/month for 10 customers) provides SSO, SCIM, admin-controlled API scopes, and org-wide mannequin coaching opt-out. The bounce from $14 to $35 per consumer (a 150% improve) buys enterprise governance options, not extra API capability.
The place the Granola API Falls Brief
These are the sensible limits a developer ought to plan round. A number of replicate the place Granola’s API is in its lifecycle (4 months outdated, three endpoints) and what the platform is (a gathering notepad, not a knowledge infrastructure layer).
The API is read-only.
There are not any create, replace, or delete operations. You may pull assembly knowledge out of Granola, however you can’t push knowledge in, create notes programmatically, replace present notes, handle folders, or set off any motion. For builds that want bidirectional sync (writing CRM knowledge again into assembly notes, for instance), the API doesn’t help the write aspect.
No webhooks or occasion streaming.
There isn’t a mechanism to obtain push notifications when new notes are created or up to date. Detecting new conferences requires polling the Listing Notes endpoint with an updated_after filter, which wastes requests and introduces latency between the assembly ending and your pipeline seeing the information.
Three endpoints is a slender floor.
Your entire API consists of checklist notes, get notes, and checklist folders. There are not any endpoints for customers, workspaces, templates, integrations, or transcripts unbiased of notes. Builders constructing something past “pull notes into one other system” will hit the boundary shortly.
No search or question functionality.
Filtering is restricted thus far ranges and folder IDs. There isn’t a full-text search, no key phrase matching, no attendee-based filtering, and no option to question notes by assembly platform, subject, or any content material attribute. Discovering particular assembly knowledge requires pulling all notes inside a time vary and filtering client-side.
Assembly context solely, no B2B intelligence.
The API returns what was mentioned in conferences. It doesn’t return who the attendees are past title and e mail, what corporations they signify, what these corporations seem like (income, headcount, tech stack), or whether or not these accounts are price pursuing.
For a developer constructing a pipeline that should act on assembly knowledge (prioritize follow-ups, enrich contacts, route leads), the hole between “assembly occurred” and “here’s what to do about it” is important.
No official SDKs, no OpenAPI spec, no sandbox.
Builders work with uncooked HTTP and cURL examples. There isn’t a downloadable spec to generate shopper code, no interactive explorer, and no option to check the API with out a paid Granola account.
ZoomInfo API: The Intelligence Layer Past Assembly Context
Granola’s API tells you what was mentioned in a gathering. ZoomInfo’s API tells you who was in that assembly, what firm they work for, what that firm’s expertise stack appears to be like like, whether or not the account exhibits shopping for intent, and the place the attendees sit within the org chart.
The 2 APIs function at totally different layers of a knowledge pipeline. A developer constructing a meeting-to-action workflow would use Granola’s API to extract dialog knowledge and ZoomInfo’s API to complement it with the B2B intelligence that drives what occurs subsequent. That intelligence comes from ZoomInfo’s GTM Context Graph, which processes 1.5B+ knowledge factors each day by combining ZoomInfo’s B2B knowledge together with your first-party indicators.

Supply: ZoomInfo
What the API Covers
ZoomInfo’s Enterprise API is a REST suite served from https://api.zoominfo.com/gtm, organized into 4 areas documented within the interactive API reference:
-
Knowledge API (Search & Enrich): Search endpoints cowl Contacts, Corporations, Intent, Information, and Scoops, returning matched information with out consuming credit. Enrich endpoints unlock full payloads: enterprise emails, direct dials, employment historical past, company hierarchy, org charts, technographics, and hashtag indicators, accepting as much as 25 information per name. The underlying dataset spans 500M contacts, 100M corporations, 135M+ verified cellphone numbers, and 200M+ verified enterprise e mail addresses.

Supply: ZoomInfo
The pairing with a gathering notes API is direct: pull attendee emails from Granola’s observe response, use ZoomInfo’s search endpoints to determine the contacts, enrich them with firm knowledge and intent indicators, then route the assembly follow-up primarily based on account intelligence quite than a abstract alone.
Authentication & Entry
ZoomInfo makes use of OAuth 2.0 with PKCE through Okta, supporting three flows: Authorization Code with PKCE (internet functions), Consumer Credentials (server-to-server), and Refresh Token. Entry tokens are 24-hour Bearer tokens with rotating refresh tokens. Purposes are registered by way of the ZoomInfo Developer Portal, the place groups generate credentials, outline scopes, and check endpoints.
It is a totally different authentication mannequin from Granola’s static API key. OAuth 2.0 helps delegated entry, credential rotation, and scoped permissions, making it a greater match for multi-tenant integrations and enterprise safety necessities.

Supply: ZoomInfo
Charge Limits, Credit & Developer Expertise
Charge limits are printed by tier: Builder (5 req/sec), Commonplace (25 req/sec), and Scaling (35 req/sec), with per-hour and per-day sliding-window limits enforced concurrently. Each response contains quota headers with remaining capability, and 429 responses embrace a Retry-After header with actual backoff timing.

Supply: ZoomInfo
Credit comply with a rolling 12-month window: enriching a file for the primary time consumes one credit score; re-enriching the identical file throughout the yr is free. Search and lookup operations don’t devour credit.
For builders constructing AI brokers, ZoomInfo’s MCP server at https://mcp.zoominfo.com/mcp exposes search, enrich, and account analysis as native instruments for MCP-compatible assistants, at present supporting Claude and ChatGPT. Documentation lives at docs.zoominfo.com with an interactive API reference, OAuth recipes in 5 languages, and an llms.txt index for AI growth instruments.

Supply: ZoomInfo
Neither platform publishes official SDKs, so each require direct HTTP integration. ZoomInfo makes use of consumption-based pricing and has added API entry to all related plans.
BDO Canada reported an 87% discount in time spent updating inner knowledge dashboards utilizing the ZoomInfo API, with one analyst describing the combination as plug-and-play throughout any course of. (ZoomInfo)
Closing Verdict
Granola’s API is early-stage and tightly scoped. It does one job: allow you to learn assembly notes, transcripts, and summaries out of Granola workspaces programmatically. The docs are clear, the endpoint design is clear, and the speed limits are printed.
For a developer whose construct begins and ends with extracting structured assembly knowledge, it really works immediately, with the understanding that three read-only endpoints outline the present ceiling.
Select the Granola API if it is advisable pull assembly notes and transcripts right into a data base, CRM, or customized AI workflow, and your construct is about consuming assembly knowledge, not appearing on it. The $14/consumer/month Marketing strategy contains API entry with no per-call expenses, making value predictable.
Select the ZoomInfo API if your construct wants the intelligence layer downstream of assembly context: figuring out who was within the assembly, enriching attendees with firm knowledge and org charts, detecting shopping for intent, and routing follow-ups primarily based on account intelligence quite than dialog summaries alone. The search-then-enrich sample (search is free, enrich consumes credit) and the Copilot API’s AI intelligence endpoints cowl the information and reasoning {that a} assembly notes API doesn’t.
Discover the ZoomInfo Enterprise API or begin with the developer docs to see the endpoint floor immediately.
A developer who wants each assembly intelligence and B2B intelligence in the identical pipeline ought to plan for each: Granola because the context seize layer, ZoomInfo because the enrichment and intelligence layer.
FAQ
Is the Granola API free?
No. API entry requires a paid Granola plan. The Fundamental (free) tier doesn’t embrace API entry. The Marketing strategy at $14/consumer/month is the entry level, with no per-call expenses or credit score system on high of the subscription. Enterprise begins at $35/consumer/month and provides admin controls over API key scopes.
Does Granola have a GraphQL API?
No. Granola exposes a REST API (at present at v1.2.0) over HTTPS with JSON responses. There isn’t a GraphQL endpoint. If you happen to want a GraphQL interface for assembly knowledge, you would want to construct a wrapper on high of the REST API.
What’s the Granola API price restrict?
The printed limits are a 25-request burst capability with a sustained price of 5 requests per second (300 requests per minute) over a 5-second window. Exceeding the restrict returns a 429 response. Pagination is capped at 30 gadgets per web page for each the Listing Notes and Listing Folders endpoints.
Are there official Granola SDKs?
No. Granola doesn’t publish official SDKs in any language. The API documentation offers uncooked cURL examples solely. There are not any maintained SDK packages, no GitHub repositories, and no group library hyperlinks. Builders combine immediately over HTTP. For AI assistant integrations, the MCP connector (which makes use of browser-based OAuth) is the really useful various to the REST API.
Does the Granola API help webhooks?
No. The Granola API is read-only and pull-based. There isn’t a webhook, event-streaming, or push-notification mechanism. Detecting new or up to date assembly notes requires polling the Listing Notes endpoint with an updated_after filter. It is a actual hole for event-driven architectures.
Can I exploit the Granola and ZoomInfo APIs collectively?
Sure, and there’s a sensible cause to take action. Granola’s API returns structured assembly knowledge together with attendee names and emails, AI-generated summaries, and timestamped transcripts. ZoomInfo’s API takes these attendee identifiers and enriches them with B2B intelligence: firm knowledge, org charts, direct-dial cellphone numbers, technographics, and shopping for intent indicators.
The workflow is sequential: pull assembly notes from Granola, extract attendee emails, search and enrich these contacts through ZoomInfo, then route follow-ups primarily based on account intelligence. ZoomInfo’s MCP server extends the identical knowledge to AI-agent workflows, so an agent that reads Granola assembly context through MCP can question ZoomInfo for account intelligence in the identical dialog.
The 2 APIs use totally different authentication fashions (static Bearer token vs. OAuth 2.0) and totally different pricing constructions (subscription-bundled vs. credit-based), so plan the combination layer accordingly.
Different instruments price evaluating aspect by aspect: