Cluely AI API Access: Build Custom Integrations That Work

Cluely AI isn’t just another ai meeting assistant—it’s a flexible, extensible platform designed for teams that need more than out-of-the-box transcription and summaries. With Cluely AI API access, developers and operations teams can embed real-time meeting intelligence directly into CRMs, internal knowledge bases, sales enablement tools, and custom dashboards. Whether you’re automating post-meeting follow-ups in Salesforce, triggering Slack alerts when key objections surface, or feeding Cluely’s insights into your LLM-powered coaching engine, the API unlocks precision control over how meeting data flows across your stack.

This isn’t theoretical: enterprise customers like Gong-adjacent sales orgs and remote-first engineering teams are already using Cluely’s RESTful API to replace brittle Zapier-based workflows with deterministic, low-latency integrations. In this cluely tutorial, we walk through everything you need to know—auth setup, endpoint capabilities, common use cases, error handling best practices, and real-world examples—to build production-ready custom integrations.

Why Cluely AI API Access Matters Now

Meeting intelligence is no longer a siloed analytics layer—it’s infrastructure. As remote work evolves, teams demand contextual, actionable insights where they already work. Cluely AI delivers rich, structured outputs: speaker-attributed transcripts, sentiment-aware summaries, action item extraction, topic clustering, and even custom-defined keyword triggers (e.g., “pricing”, “competitor”, “POC timeline”). But without API access, those insights stay trapped in Cluely’s UI.

The Cluely AI API bridges that gap. It lets you:

Pull raw and processed meeting data programmatically (JSON, not screenshots)
Trigger Cluely recordings via webhook or scheduled sync
Enrich third-party events (e.g., HubSpot deal stage changes) with Cluely-derived insights
Build internal tools like a “meeting health score” dashboard or an automated coaching feedback loop

Unlike generic transcription APIs, Cluely’s endpoints are purpose-built for business meetings: speaker diarization is optimized for hybrid calls, summaries retain negotiation nuance, and action items include assignee confidence scoring—critical context most cluely review analyses overlook.

Getting Started: Authentication & API Keys

Cluely AI uses OAuth 2.0 with PKCE for secure, user-scoped access—and API keys for server-to-server integrations. Most custom workflows begin with the latter.

Generating Your API Key

Log into your Cluely AI account as an admin or team owner
Navigate to Settings → Developer → API Keys
Click + Create New Key, give it a descriptive name (e.g., salesforce-sync-prod), and select scopes:
- meetings:read (required for all read operations)
- meetings:transcript (to fetch full speaker-labeled transcripts)
- meetings:summary (for executive summaries and action items)
- webhooks:manage (if you’ll configure event-driven triggers)
Copy the generated key immediately—Cluely does not store or re-display it

⚠️ Best practice: Store keys in environment variables (CLUELY_API_KEY) or a secrets manager—not hardcoded in source. Rotate keys quarterly or after team member offboarding.

Base URL & Rate Limits

All endpoints live under https://api.cluely.ai/v1. Cluely enforces fair-use rate limits:

100 requests/minute per API key (burst up to 200)
5,000 meetings/month on Pro plans; 20,000 on Enterprise
Exceeding limits returns HTTP 429 with Retry-After header

You can monitor usage in real time via the Developer Dashboard, which shows last 7 days of calls, top endpoints, and error rates.

Core Endpoints & What They Return

Cluely’s API is built around four core resources: meetings, transcripts, summaries, and webhooks. Here’s what each delivers—and how to use them effectively.

List & Filter Meetings

Use GET /meetings to retrieve metadata for recent meetings. Supports powerful filtering:

curl -H "Authorization: Bearer $CLUELY_API_KEY" \
  "https://api.cluely.ai/v1/meetings?start_time=2024-05-01T00:00:00Z&end_time=2024-05-31T23:59:59Z&tags=sales-demo&limit=50"

Response includes:

id, title, start_time, duration_seconds
participants (email + role)
tags, custom_fields, recording_url
status: processed, processing, or failed

💡 Pro tip: Use tags to categorize meetings before recording (via Cluely browser extension or calendar sync). Then filter by tag later to isolate sales demos vs. customer onboarding sessions.

Fetch Transcript & Speaker Attribution

GET /meetings/{id}/transcript returns a JSON array of utterances with:

speaker_id, speaker_name, is_customer (boolean)
text, start_ms, end_ms
confidence_score (0.0–1.0) for speaker diarization accuracy

Example snippet:

{
  "speaker_name": "Alex Chen",
  "is_customer": false,
  "text": "Let me walk you through our new API pricing tiers.",
  "start_ms": 12480,
  "end_ms": 15210,
  "confidence_score": 0.96
}

This structure makes it trivial to build logic like: “If ‘pricing’ appears in >2 utterances by a non-customer speaker within 30 seconds, flag for sales ops review.”

Retrieve Actionable Summaries

GET /meetings/{id}/summary gives you Cluely’s distilled output:

executive_summary: 3–5 sentence overview
action_items: array with text, assignee_email, due_date, confidence (0.72–0.98)
key_topics: ranked list with relevance scores
sentiment_overview: positive, neutral, or negative, plus sentiment_timeline (per-minute breakdown)

This is where Cluely shines as an ai meeting assistant—no manual parsing needed. You can pipe action_items directly into Jira or Linear via their APIs, or feed key_topics into your vector DB for semantic search across historical deals.

Real-World Integration Examples

Here are three production-grade patterns we’ve helped customers ship—with code snippets and architecture notes.

1. Auto-Create Salesforce Tasks from Action Items

When Cluely detects an action item like “Send security whitepaper to devops@acme.com by Friday”, create a Task in Salesforce with pre-filled subject, due date, and owner.

Workflow:

Poll /meetings?status=processed&updated_after={last_check} every 5 mins
For each new meeting, call /meetings/{id}/summary
Parse action_items, filter for confidence > 0.85
POST to Salesforce REST API (/services/data/v60.0/sobjects/Task/) with mapped fields

✅ Benefit: Cuts manual task entry by ~70% for AE teams; ensures nothing slips through cracks.

2. Slack Alert on Competitor Mentions

Trigger a private Slack message to your product team when a competitor is named ≥3 times in a single meeting.

How:

Use /meetings/{id}/transcript to get full text
Run simple regex or keyword count (e.g., /(gong|chime|zoom|teams)/gi)
If count ≥ 3, POST to Slack webhook with meeting title, link, and transcript excerpt

💡 Bonus: Add sentiment_overview to indicate if the mention was positive (“Gong’s UI is clean”) or negative (“Gong’s pricing is opaque”).

3. Internal Coaching Dashboard with Meeting Health Scoring

Build a real-time dashboard showing weekly “coaching readiness” scores based on:

% of meetings with ≥2 clear action items
Avg. speaking time balance (customer vs. rep)
Frequency of objection-handling phrases (“I understand…”, “Let me clarify…”)

Pull data nightly via /meetings?tag=coaching-session, compute metrics, and push to Metabase or Grafana.

These aren’t hypothetical—they’re live in more tutorials covering sales, support, and engineering use cases.

Webhooks: Event-Driven Workflows (No Polling Needed)

Instead of polling /meetings every few minutes, use Cluely’s webhooks to receive real-time notifications when meetings complete processing.

Go to Settings → Developer → Webhooks
Add endpoint URL (must accept POST, return 2xx)
Select events: meeting.processed, meeting.failed, meeting.transcript.updated
Enable signature verification (Cluely signs payloads with X-Cluely-Signature HMAC-SHA256)

Sample payload for meeting.processed:

{
  "event": "meeting.processed",
  "meeting_id": "m_abc123",
  "timestamp": "2024-05-22T14:32:18Z",
  "data": {
    "title": "Acme Demo - May 22",
    "duration_seconds": 1842,
    "tags": ["sales-demo", "enterprise"]
  }
}

Then your service can immediately fetch /meetings/m_abc123/summary and act—no latency, no wasted API calls. This pattern powers many of our customers’ browse Integrations tutorials.

Debugging & Best Practices

Even well-designed integrations hit snags. Here’s how to stay ahead:

Always check status before fetching transcript/summary: A meeting may be processing for 60–90 seconds after recording ends.
Handle 404 Not Found gracefully: Meetings may be deleted or permissions revoked. Don’t crash—log and skip.
Respect X-RateLimit-Remaining: Check headers and back off before hitting 0.
Validate is_customer: Cluely auto-detects customer emails from calendar invites—but verify against your CRM’s domain list to avoid misattribution.
Test with sandbox data first: Use Cluely’s contact us team to request a test API key with synthetic meeting data.

Cluely’s API docs (available at https://docs.cluely.ai) include interactive try-it-now consoles, SDKs for Python and Node.js, and Postman collections—all updated in real time with each release.

Final Thoughts: Building Intelligence, Not Just Integrations

Cluely AI API access transforms meeting data from passive archives into active business infrastructure. It’s not about connecting two apps—it’s about creating feedback loops that improve rep performance, accelerate deal velocity, and surface risks before they escalate. Whether you’re a solo developer building your first workflow or an enterprise architect designing a company-wide meeting intelligence layer, Cluely gives you the primitives: reliable transcripts, nuanced summaries, and predictable, documented endpoints.

Start small: automate one manual step (e.g., Slack alerts for lost deals). Measure the time saved. Then expand—add CRM enrichment, then coaching triggers, then predictive scoring. Every integration compounds value.

And remember: Cluely isn’t just another ai meeting assistant. It’s the only one built from day one to power your stack—not replace it.

Key takeaways:

Generate API keys with minimal required scopes—never *.
Prefer webhooks over polling for real-time responsiveness.
Leverage is_customer, confidence_score, and sentiment_timeline—they’re what make Cluely’s output uniquely actionable.
Test rigorously with edge cases: empty transcripts, overlapping speakers, failed processing.
Refer to official cluely tutorial resources and join our developer Slack community for peer support.

Ready to go deeper? Explore our browse Integrations tutorials for step-by-step guides on syncing with Notion, HubSpot, and Microsoft Teams—or contact us for enterprise onboarding support.