Complete Fireflies integration skill pack with 24 skills covering meeting transcription, AI summaries, and conversation intelligence. Flagship tier vendor pack.

24 plugin-local skills

MIT License

Claude Code Adapters (declared)

Installation

Open Claude Code and run this command:

/plugin install fireflies-pack@claude-code-plugins-plus

Use --global to install for all projects, or --project for current project only.

What It Does

> 24 production-ready skills for the Fireflies.ai GraphQL API -- transcript retrieval, AskFred AI, webhook processing, meeting analytics, and enterprise access control.

Fireflies.ai is an AI meeting notetaker that auto-joins video calls (Zoom, Google Meet, Teams), generates speaker-diarized transcripts, extracts action items, and provides AI-powered Q&A via AskFred. This skill pack covers the entire Fireflies GraphQL API surface at https://api.fireflies.ai/graphql.

Skills (24) plugin-local skills

fireflies-ci-integration View full skill →

Configure CI/CD pipelines for Fireflies.

ReadWriteEditBash(gh:*)

Fireflies.ai CI Integration

Overview

Set up CI/CD pipelines for Fireflies.ai integrations: GraphQL query validation, mock-based unit tests, and optional live API integration tests with rate limit awareness.

Examples

Run pull-request tests against synthetic GraphQL responses with no credentials. After merge, a protected job validates one fictitious staging meeting with a scoped secret and emits only schema and aggregate delivery results; an unexpected field or destination blocks promotion.

Prerequisites

GitHub repository with Actions enabled
Fireflies.ai test API key (for integration tests)
Vitest test suite configured

Instructions

Step 1: GitHub Actions Workflow


# .github/workflows/fireflies-tests.yml
name: Fireflies Integration Tests

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

jobs:
  unit-tests:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: "20"
          cache: "npm"
      - run: npm ci
      - run: npm test -- --coverage
      - name: Upload coverage
        uses: actions/upload-artifact@v4
        with:
          name: coverage
          path: coverage/

  integration-tests:
    runs-on: ubuntu-latest
    if: github.event_name == 'push' && github.ref == 'refs/heads/main'
    needs: unit-tests
    environment: staging
    env:
      FIREFLIES_API_KEY: ${{ secrets.FIREFLIES_API_KEY_TEST }}
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: "20"
          cache: "npm"
      - run: npm ci
      - name: Run integration tests
        run: npm run test:integration
        timeout-minutes: 5

Step 2: Store Secrets


set -euo pipefail
# Store test API key as GitHub secret
gh secret set FIREFLIES_API_KEY_TEST --body "your-test-api-key"

# For production deployments
gh secret set FIREFLIES_API_KEY_PROD --env production --body "your-prod-key"
gh secret set FIREFLIES_WEBHOOK_SECRET --env production --body "your-webhook-secret"

Step 3: Unit Tests with Mocks


// tests/fireflies-client.test.ts
import { describe, it, expect, vi, beforeEach } from "vitest";

// Mock fetch globally
const mockFetch = vi.fn();
vi.stubGlobal("fetch", mockFetch);

describe("Fireflies GraphQL Client", () => {
  beforeEach(() => {
    vi.clearAllMocks();
    process.env.FIREFLIES_API_KEY = "test-key";
  });

  it("should send correct auth header", async () => {
    mockFetch.mockResolvedValue({
      json: () => Promise.resolve({ data: { user: { email: "test@co.com" } } }),
    });

    cons


                
                  
                  fireflies-common-errors
                  View full skill →
                
                
                  Diagnose and fix Fireflies.
                  
                      ReadGrepBash(curl:*)
                    
                
                
                  Fireflies.ai Common Errors
Overview
Quick reference for all Fireflies.ai GraphQL API error codes with root causes and fixes.
Prerequisites

An authorized support role, opaque correlation ID, and access to redacted application telemetry.
A synthetic meeting or read-only query for safe reproduction; never use a real transcript for routine diagnosis.
An incident owner for access, consent, retention, or credential concerns.

Instructions

Classify the error as authentication, authorization, schema, throttling, quota, or upstream availability.
Reproduce with the smallest read-only synthetic query, then check scopes, query shape, rate controls, and queue state.
Apply a reversible correction and confirm both the expected response and safe failure behavior.
Pause processing and escalate immediately for unexpected transcript access, consent issues, or possible credential exposure.

Error Handling

Do not retry authentication or permission failures with broader credentials; route them to the authorized owner.
Use bounded backoff and idempotency for throttles; quarantine exhausted jobs for review.
Redact transcript content, participant identity, and authorization headers from diagnostic evidence.

Examples
Use a synthetic query that triggers a controlled validation error, record the error category and opaque request ID, correct the query shape, and verify success. For an authorization failure, stop the worker until the approved owner adjusts scope and validates a read-only request.
Error Response Format
All Fireflies errors follow this GraphQL error structure:

{
  "errors": [{
    "message": "Human-readable description",
    "code": "error_code",
    "friendly": true,
    "extensions": {
      "status": 400,
      "helpUrls": ["https://docs.fireflies.ai/..."]
    }
  }]
}

Error Code Reference
auth_failed (401)
Message: Invalid or missing API key.

# Verify API key is set and valid
echo "Key set: ${FIREFLIES_API_KEY:+YES}"

# Test authentication
set -euo pipefail
curl -s -X POST https://api.fireflies.ai/graphql \
  -H "Authorization: Bearer $FIREFLIES_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"query": "{ user { email } }"}' | jq .

Fix: Regenerate API key at app.fireflies.ai > Integrations > Fireflies API.

too_many_requests (429)
Message: Rate limit exceeded.

Plan
Limit


Free / Pro
50 requests per day
                
              
                
                  
                  fireflies-core-workflow-a
                  View full skill →
                
                
                  Retrieve and process Fireflies.
                  
                      ReadWriteEditBash(npm:*)Bash(curl:*)Grep
                    
                
                
                  Fireflies.ai Core Workflow A -- Transcript Retrieval & Processing
Overview
Primary workflow for Fireflies.ai: fetch meeting transcripts via GraphQL, process speaker-diarized sentences, extract action items and summaries, and route meeting intelligence downstream.
Examples
In staging, process a synthetic transcript with fictional speakers and route only approved action-item fields to a test destination. Confirm that raw transcript text stays in the authorized system, downstream delivery is idempotent, and deleting the test record removes access according to the retention policy.
Prerequisites

Completed fireflies-install-auth setup
FIREFLIES_API_KEY set with Business+ plan for full access
At least one completed meeting in Fireflies

Instructions
Step 1: Build the GraphQL Client

// lib/fireflies.ts
const FIREFLIES_API = "https://api.fireflies.ai/graphql";

export async function firefliesQuery<T = any>(
  query: string,
  variables?: Record<string, any>
): Promise<T> {
  const res = await fetch(FIREFLIES_API, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      Authorization: `Bearer ${process.env.FIREFLIES_API_KEY}`,
    },
    body: JSON.stringify({ query, variables }),
  });

  const json = await res.json();
  if (json.errors) {
    const err = json.errors[0];
    throw new Error(`Fireflies API error: ${err.message} (${err.code || "unknown"})`);
  }
  return json.data;
}

Step 2: List Transcripts with Filters

const LIST_TRANSCRIPTS = `
  query ListTranscripts(
    $limit: Int,
    $mine: Boolean,
    $fromDate: DateTime,
    $toDate: DateTime,
    $organizers: [String],
    $participants: [String]
  ) {
    transcripts(
      limit: $limit
      mine: $mine
      fromDate: $fromDate
      toDate: $toDate
      organizers: $organizers
      participants: $participants
    ) {
      id title date duration
      organizer_email participants
      summary { overview action_items keywords }
    }
  }
`;

// Fetch this week's meetings for a specific organizer
const data = await firefliesQuery(LIST_TRANSCRIPTS, {
  limit: 20,
  fromDate: "2026-03-15T00:00:00Z",
  organizers: ["alice@company.com"],
});

Step 3: Fetch Full Transcript with Sentences

const GET_TRANSCRIPT = `
  query GetTranscript($id: String!) {
    transcript(id: $id) {
      id title date duration
      organizer_email
      speakers { id name }
      sentences {
        index
        speaker_name
        speaker_id
        text
        raw_text
        start_time
        end_time
        ai_filters {
          task
          question
          sentiment
          pricing
          metric

                

              

                
                  
                  fireflies-core-workflow-b
                  View full skill →
                
                
                  Search across Fireflies.
                  
                      ReadWriteEditBash(curl:*)Grep
                    
                
                
                  Fireflies.ai Core Workflow B -- Search, AskFred & Analytics
Overview
Secondary workflow: search across transcripts with keyword and date filters, use AskFred AI for natural language Q&A over meetings, and aggregate meeting analytics for reporting.
Examples
Search a synthetic meeting set using a narrow date range and a fictional keyword, then return only aggregate counts and approved action-item categories. Confirm that the destination never receives raw transcript passages or participant identities unless the documented access policy permits them.
Prerequisites

Completed fireflies-install-auth setup
Familiarity with fireflies-core-workflow-a
AI credits for AskFred queries (check Fireflies dashboard)

Instructions
Step 1: Search Transcripts by Keyword

const SEARCH_TRANSCRIPTS = `
  query SearchMeetings(
    $keyword: String,
    $fromDate: DateTime,
    $toDate: DateTime,
    $participants: [String],
    $limit: Int
  ) {
    transcripts(
      keyword: $keyword
      fromDate: $fromDate
      toDate: $toDate
      participants: $participants
      limit: $limit
    ) {
      id title date duration
      organizer_email
      participants
      summary { overview action_items keywords }
    }
  }
`;

// Search for "quarterly review" in the last 30 days
const results = await firefliesQuery(SEARCH_TRANSCRIPTS, {
  keyword: "quarterly review",
  fromDate: new Date(Date.now() - 30 * 86400000).toISOString(),
  limit: 20,
});

console.log(`Found ${results.transcripts.length} matching meetings`);
for (const t of results.transcripts) {
  console.log(`  ${t.title} (${t.date}) - ${t.duration}min`);
}

Step 2: AskFred -- AI Q&A Over a Single Meeting

// Create a new AskFred thread tied to a transcript
const CREATE_THREAD = `
  mutation CreateThread($input: CreateAskFredThreadInput!) {
    createAskFredThread(input: $input) {
      id
      title
      messages {
        id
        answer
        suggested_queries
      }
    }
  }
`;

const thread = await firefliesQuery(CREATE_THREAD, {
  input: {
    query: "What were the key decisions made in this meeting?",
    transcript_id: "your-transcript-id",
  },
});

console.log("Fred says:", thread.createAskFredThread.messages[0].answer);
console.log("Suggested follow-ups:", thread.createAskFredThread.messages[0].suggested_queries);

Step 3: AskFred -- Continue a Conversation

const CONTINUE_THREAD = `
  mutation ContinueThread($thread_id: String!, $query: String!) {
    continueAskFredThread(thread_id: $thread_id, query: $query) {
      id
      answer
      suggested_queries
    }
  }
`;

const followUp = await firefliesQuery(CONTINUE_THREAD, {
  thread_id: thread.crea

                

              

                
                  
                  fireflies-cost-tuning
                  View full skill →
                
                
                  Optimize Fireflies.
                  
                      ReadBash(curl:*)Grep
                    
                
                
                  Fireflies.ai Cost Tuning
Overview
Optimize Fireflies.ai subscription costs. Fireflies charges per-seat per month. The main levers: remove unused seats, configure selective recording, manage storage, and right-size your plan tier.
Prerequisites

Current contract and billing data reviewed by the account owner; do not treat examples as current pricing.
Aggregate seat, storage, and workflow usage data, without transcript content or participant identities.
A documented approval and retention process before removing seats, recordings, or integrations.

Examples
Use aggregate utilization to find an inactive test seat, confirm ownership and retention requirements, and remove it only after the approver records the decision. Verify that access is revoked while retained records follow the approved policy.
Pricing Reference

Plan
Price
API Access
Key Features


Free
$0
50 req/day
800 min storage, limited transcription


Pro
~$18/seat/month
50 req/day
8,000 min/seat, AI summaries


Business
~$29/seat/month
60 req/min
Unlimited transcription, CRM, analytics


Enterprise
Custom
60 req/min
SSO, Super Admin webhooks, custom


Instructions
Step 1: Audit Seat Utilization via API

set -euo pipefail
# List all workspace users with their transcript counts
curl -s -X POST https://api.fireflies.ai/graphql \
  -H "Authorization: Bearer $FIREFLIES_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"query": "{ users { name email user_id num_transcripts minutes_consumed } }"}' \
  | jq '.data.users | sort_by(.num_transcripts) | .[] | {name, email, transcripts: .num_transcripts, minutes: .minutes_consumed}'


// Automated utilization report
async function seatUtilizationReport() {
  const data = await firefliesQuery(`{
    users {
      name email user_id
      num_transcripts minutes_consumed
      recent_meeting
    }
  }`);

  const users = data.users;
  const inactive = users.filter((u: any) => u.num_transcripts < 2);
  const active = users.filter((u: any) => u.num_transcripts >= 2);

  console.log(`Total seats: ${users.length}`);
  console.log(`Active (2+ transcripts): ${active.length}`);
  console.log(`Inactive (<2 transcripts): ${inactive.length}`);
  console.log(`Potential savings: ${inactive.length} seats * $29/mo = $${inactive.length * 29}/mo`);

  if (inactive.length > 0) {
    console.log("\nInactive seats to review:");
    for (const u of inactive) {
      console.log(`  ${u.email}: ${u.num_transcripts} transcripts, last me

                

              

                
                  
                  fireflies-data-handling
                  View full skill →
                
                
                  Handle Fireflies.
                  
                      ReadWriteEdit
                    
                
                
                  Fireflies.ai Data Handling
Overview
Manage meeting transcript data: export in multiple formats (JSON, text, SRT), redact PII from transcripts and summaries, implement retention policies with automated cleanup, and handle GDPR/CCPA data subject requests.
Examples
Use a fictional transcript to test redaction and retention logic. Confirm that the export is restricted to an approved test destination, logs contain only aggregate counts, and deleting the record removes both the raw and derived test artifacts according to the configured policy.
Prerequisites

FIREFLIES_API_KEY configured
Understanding of transcript data structure (sentences, summary, analytics)
Storage for processed transcripts

Instructions
Step 1: Fetch Transcript Data

const FIREFLIES_API = "https://api.fireflies.ai/graphql";

async function getFullTranscript(id: string) {
  const res = await fetch(FIREFLIES_API, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      Authorization: `Bearer ${process.env.FIREFLIES_API_KEY}`,
    },
    body: JSON.stringify({
      query: `
        query($id: String!) {
          transcript(id: $id) {
            id title date duration
            organizer_email
            speakers { id name }
            sentences { speaker_name text start_time end_time }
            summary { overview action_items keywords short_summary }
            meeting_attendees { displayName email }
          }
        }
      `,
      variables: { id },
    }),
  });
  const json = await res.json();
  if (json.errors) throw new Error(json.errors[0].message);
  return json.data.transcript;
}

Step 2: Export in Multiple Formats

type ExportFormat = "json" | "text" | "srt" | "csv";

function exportTranscript(transcript: any, format: ExportFormat): string {
  switch (format) {
    case "json":
      return JSON.stringify(transcript, null, 2);

    case "text":
      const lines = [
        `# ${transcript.title}`,
        `Date: ${transcript.date} | Duration: ${transcript.duration}min`,
        `Speakers: ${transcript.speakers.map((s: any) => s.name).join(", ")}`,
        "",
        "## Summary",
        transcript.summary?.overview || "(none)",
        "",
        "## Action Items",
        ...(transcript.summary?.action_items || []).map((a: string) => `- ${a}`),
        "",
        "## Transcript",
        ...transcript.sentences.map((s: any) =>
          `[${fmtTime(s.start_time)}] ${s.speaker_name}: ${s.text}`
        ),
      ];
      return lines.join("\n");

    case "srt":
      return transcript.sentences.map((s: any, i: number) =

                

              

                
                  
                  fireflies-debug-bundle
                  View full skill →
                
                
                  Collect Fireflies.
                  
                      ReadBash(curl:*)Bash(tar:*)Grep
                    
                
                
                  Fireflies.ai Debug Bundle
Current State
!node --version 2>/dev/null || echo 'N/A' !python3 --version 2>/dev/null || echo 'N/A'
Overview
Collect all diagnostic information needed to resolve Fireflies.ai integration issues. Generates a redacted bundle safe for sharing with support.
Examples
For a synthetic authentication failure, collect runtime versions, an opaque request ID, and the configured scope reference—not a transcript, email, token, or raw response. Review and encrypt the bundle in the approved evidence location, share it only with the incident owner, and retire it at the documented retention date.
Prerequisites

FIREFLIES_API_KEY environment variable set
curl and jq available
Permission to collect environment info

Instructions
Step 1: Create Debug Bundle Script

#!/bin/bash
set -euo pipefail

BUNDLE_DIR="fireflies-debug-$(date +%Y%m%d-%H%M%S)"
mkdir -p "$BUNDLE_DIR"

echo "=== Fireflies.ai Debug Bundle ===" > "$BUNDLE_DIR/summary.txt"
echo "Generated: $(date -u +%Y-%m-%dT%H:%M:%SZ)" >> "$BUNDLE_DIR/summary.txt"
echo "" >> "$BUNDLE_DIR/summary.txt"

# 1. Environment
echo "--- Environment ---" >> "$BUNDLE_DIR/summary.txt"
echo "Node: $(node --version 2>/dev/null || echo 'N/A')" >> "$BUNDLE_DIR/summary.txt"
echo "Python: $(python3 --version 2>/dev/null || echo 'N/A')" >> "$BUNDLE_DIR/summary.txt"
echo "OS: $(uname -s) $(uname -r)" >> "$BUNDLE_DIR/summary.txt"
echo "API Key: ${FIREFLIES_API_KEY:+SET (${#FIREFLIES_API_KEY} chars)}" >> "$BUNDLE_DIR/summary.txt"
echo "" >> "$BUNDLE_DIR/summary.txt"

# 2. API Connectivity
echo "--- API Connectivity ---" >> "$BUNDLE_DIR/summary.txt"
curl -s -o "$BUNDLE_DIR/api-response.json" -w "HTTP %{http_code} | %{time_total}s\n" \
  -X POST https://api.fireflies.ai/graphql \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $FIREFLIES_API_KEY" \
  -d '{"query": "{ user { name email is_admin } }"}' \
  >> "$BUNDLE_DIR/summary.txt" 2>&1

# 3. User & Plan Info
echo "" >> "$BUNDLE_DIR/summary.txt"
echo "--- Account Info ---" >> "$BUNDLE_DIR/summary.txt"
curl -s -X POST https://api.fireflies.ai/graphql \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $FIREFLIES_API_KEY" \
  -d '{"query": "{ user { name email is_admin num_transcripts minutes_consumed is_calendar_in_sync

                

              

                
                  
                  fireflies-deploy-integration
                  View full skill →
                
                
                  Deploy Fireflies.
                  
                      ReadWriteEditBash(vercel:*)Bash(docker:*)Bash(gcloud:*)
                    
                
                
                  Fireflies.ai Deploy Integration
Overview
Deploy Fireflies.ai integrations across platforms. Covers GraphQL client setup, webhook receiver deployment, and secret management for Vercel, Docker, and Google Cloud Run.
Examples
Deploy a staging receiver using platform-injected scoped secrets and a synthetic signed event. Verify that health responses contain no transcript data, a bad signature is rejected, and a failed canary can be rolled back before any production transcript destination is enabled.
Prerequisites

Fireflies.ai Business+ plan for API access
FIREFLIES_API_KEY and FIREFLIES_WEBHOOK_SECRET ready
Platform CLI installed (vercel, docker, or gcloud)

Instructions
Step 1: Shared GraphQL Client

// lib/fireflies.ts
const FIREFLIES_API = "https://api.fireflies.ai/graphql";

export async function firefliesQuery(query: string, variables?: any) {
  const res = await fetch(FIREFLIES_API, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      Authorization: `Bearer ${process.env.FIREFLIES_API_KEY}`,
    },
    body: JSON.stringify({ query, variables }),
  });

  const json = await res.json();
  if (json.errors) throw new Error(json.errors[0].message);
  return json.data;
}

Step 2: Webhook Receiver (Next.js / Vercel)

// app/api/webhooks/fireflies/route.ts
import crypto from "crypto";

export async function POST(req: Request) {
  const rawBody = await req.text();
  const signature = req.headers.get("x-hub-signature") || "";

  // Verify HMAC-SHA256 signature
  const expected = crypto
    .createHmac("sha256", process.env.FIREFLIES_WEBHOOK_SECRET!)
    .update(rawBody)
    .digest("hex");

  if (!crypto.timingSafeEqual(Buffer.from(signature), Buffer.from(expected))) {
    return Response.json({ error: "Invalid signature" }, { status: 401 });
  }

  const event = JSON.parse(rawBody);

  if (event.eventType === "Transcription completed") {
    // Fetch transcript data
    const data = await firefliesQuery(`
      query($id: String!) {
        transcript(id: $id) {
          id title duration
          speakers { name }
          summary { overview action_items }
        }
      }
    `, { id: event.meetingId });

    // Process transcript (store, notify, create tasks)
    console.log(`Processed: ${data.transcript.title}`);
  }

  return Response.json({ received: true });
}

Step 3: Deploy to Vercel

set -euo pipefail
# Add secrets
vercel env add FIREFLIES_API_KEY production
vercel env add FIREFLIES_WEBHOOK_SECRET production

# Deploy
vercel --prod

# Register webhook URL in Fireflies dashboard:
# https://your-app.vercel.app/api/webhooks/fireflies

                

              

                
                  
                  fireflies-enterprise-rbac
                  View full skill →
                
                
                  Configure Fireflies.
                  
                      ReadWriteEditBash(curl:*)
                    
                
                
                  Fireflies.ai Enterprise RBAC
Overview
Manage workspace access control in Fireflies.ai using roles, channels, privacy levels, and the sharing API. Fireflies uses per-seat licensing with workspace roles and channel-based transcript organization.
Examples
Create a test channel containing a fictional meeting, grant a temporary least-privilege role, and verify it can access only that channel. Remove the role and confirm access is revoked; record the review outcome without storing participant or transcript data.
Prerequisites

Fireflies Business or Enterprise plan
Workspace admin privileges (or API key from admin account)
Understanding of your team structure

Workspace Roles

Role
Capabilities


Admin
Full workspace control, manage members, access all transcripts


Member
Record meetings, view own + shared transcripts


Guest
View shared transcripts only (may not consume a seat)


Instructions
Step 1: List Workspace Members

set -euo pipefail
curl -s -X POST https://api.fireflies.ai/graphql \
  -H "Authorization: Bearer $FIREFLIES_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"query": "{ users { name email user_id is_admin num_transcripts } }"}' \
  | jq '.data.users[] | {name, email, admin: .is_admin, transcripts: .num_transcripts}'

Step 2: Set User Roles via API

// Promote or change a user's role
async function setUserRole(userId: string, role: string) {
  return firefliesQuery(`
    mutation($userId: String!, $role: String!) {
      setUserRole(user_id: $userId, role: $role)
    }
  `, { userId, role });
}

// Usage: setUserRole("user-id-123", "admin")

Step 3: Organize Transcripts with Channels

// List all channels
const channels = await firefliesQuery(`{
  channels {
    id
    title
    is_private
    created_by
    members { user_id email name }
  }
}`);

// Move transcripts to a channel
async function assignToChannel(transcriptIds: string[], channelId: string) {
  return firefliesQuery(`
    mutation($ids: [String!]!, $channelId: String!) {
      updateMeetingChannel(transcript_ids: $ids, channel_id: $channelId)
    }
  `, { ids: transcriptIds, channelId });
}

Organize by department:

Sales channel: All client/prospect calls
Engineering channel: Sprint reviews, architecture discussions
Leadership channel (private): Board meetings, strategy sessions

Step 4: Control Transcript Privacy

// Privacy levels (m

                

              

                
                  
                  fireflies-hello-world
                  View full skill →
                
                
                  Create a minimal working Fireflies.
                  
                      ReadWriteEditBash(curl:*)
                    
                
                
                  Fireflies.ai Hello World
Overview
Minimal working examples demonstrating core Fireflies.ai GraphQL queries: list users, fetch transcripts, and read a meeting summary.
Examples
Start with a synthetic meeting that has invented speakers and a minimal summary. Query only an opaque ID and schema result, verify logs redact headers and content, and delete the test record after confirming retention behavior. Never use a real meeting as a quick-start fixture.
Prerequisites

Completed fireflies-install-auth setup
FIREFLIES_API_KEY environment variable set
At least one meeting recorded in Fireflies

Instructions
Step 1: List Workspace Users

set -euo pipefail
curl -s -X POST https://api.fireflies.ai/graphql \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $FIREFLIES_API_KEY" \
  -d '{"query": "{ users { name user_id email } }"}' | jq '.data.users'

Step 2: Fetch Recent Transcripts

const FIREFLIES_API = "https://api.fireflies.ai/graphql";

async function firefliesQuery(query: string, variables?: Record<string, any>) {
  const res = await fetch(FIREFLIES_API, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      Authorization: `Bearer ${process.env.FIREFLIES_API_KEY}`,
    },
    body: JSON.stringify({ query, variables }),
  });
  const json = await res.json();
  if (json.errors) throw new Error(json.errors[0].message);
  return json.data;
}

// List 5 most recent transcripts
const data = await firefliesQuery(`
  query RecentMeetings {
    transcripts(limit: 5) {
      id
      title
      date
      duration
      organizer_email
      participants
    }
  }
`);

for (const t of data.transcripts) {
  console.log(`${t.title} (${t.duration}min) - ${t.date}`);
  console.log(`  Organizer: ${t.organizer_email}`);
  console.log(`  Participants: ${t.participants?.join(", ")}`);
}

Step 3: Read a Single Transcript with Summary

async function getTranscriptSummary(id: string) {
  return firefliesQuery(`
    query GetTranscript($id: String!) {
      transcript(id: $id) {
        id
        title
        date
        duration
        organizer_email
        speakers { id name }
        summary {
          overview
          short_summary
          action_items
          keywords
        }
      }
    }
  `, { id });
}

const { transcript } = await getTranscriptSummary("your-transcript-id");
console.log(`Title: ${transcript.title}`);
console.log(`Summary: ${transcript.summary.overview}`);
console.log(`Action Items: ${transcript.summary.action_items?.join("\n  - ")}`);
console.log(`Keywords: ${transcript.summary.keywords?.jo

                

              

                
                  
                  fireflies-incident-runbook
                  View full skill →
                
                
                  Execute Fireflies.
                  
                      ReadGrepBash(curl:*)
                    
                
                
                  Fireflies.ai Incident Runbook
Overview
Rapid incident response procedures for Fireflies.ai integration failures. Covers API outages, authentication problems, webhook issues, and rate limiting.
Prerequisites

A declared incident commander, communication owner, secure evidence location, and escalation path.
Credential-revocation and queue-disable procedures, plus redaction rules for transcripts and participants.
Aggregate health probes that can be run without retrieving a real transcript.

Instructions

Assign severity and incident owner, record an opaque incident ID, and pause unsafe automation or sharing paths.
Classify the event as availability, access, webhook, throttle, retention, or potential data exposure.
Apply the smallest safe mitigation, verify recovery with a synthetic/read-only probe, and test the safe failure path.
Revoke or rotate credentials when exposure is possible; do not resume queued work until permission and idempotency checks pass.
Record timeline, impact, owner decisions, corrective actions, and the post-incident review date.

Examples
During a synthetic API outage, pause a transcript-routing worker, verify that queued events do not resend, and publish a redacted status receipt. Restore one canary only after the health probe recovers, then resume production processing with commander approval.
Severity Levels

Level
Definition
Response Time
Examples


P1
Integration fully broken
< 15 min
auth_failed on all requests


P2
Degraded functionality
< 1 hour
Rate limiting, slow responses


P3
Minor impact
< 4 hours
Webhook delays, missing summaries


P4
No user impact
Next business day
Monitoring gaps


Quick Triage (Run First)

set -euo pipefail
echo "=== Fireflies.ai Incident Triage ==="
echo ""

# 1. Can we reach the API?
echo "--- API Connectivity ---"
curl -s -o /dev/null -w "HTTP %{http_code} (%{time_total}s)\n" \
  -X POST https://api.fireflies.ai/graphql \
  -H "Authorization: Bearer $FIREFLIES_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"query": "{ user { email } }"}'

# 2. What error are we getting?
echo ""
echo "--- API Response ---"
curl -s -X POST https://api.fireflies.ai/graphql \
  -H "Authorization: Bearer $FIREFLIES_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"query": "{ user { email is_admin } }"}' | jq .

# 3. Can we list transcripts?
echo ""
ech

                

              

                
                  
                  fireflies-install-auth
                  View full skill →
                
                
                  Configure Fireflies.
                  
                      ReadWriteEditBash(npm:*)Bash(curl:*)Grep
                    
                
                
                  Fireflies.ai Install & Auth
Overview
Set up Fireflies.ai GraphQL API authentication. Fireflies uses a single GraphQL endpoint at https://api.fireflies.ai/graphql with Bearer token auth. No SDK needed -- all interaction is via HTTP POST with GraphQL queries.
Examples
Store a scoped staging key in the approved secret manager and run a read-only query against a fictitious test workspace. Record only the authentication method, scope, and redacted outcome; then revoke the test credential to confirm access does not persist unexpectedly.
Prerequisites

Fireflies.ai account (Pro or higher for API access)
API key from app.fireflies.ai > Integrations > Fireflies API
Node.js 18+ or Python 3.10+
A GraphQL client library (optional but recommended)

Instructions
Step 1: Get Your API Key

Log in at app.fireflies.ai
Navigate to Integrations > Fireflies API
Copy your API key (starts with a long alphanumeric string)
Store it securely -- this key grants access to all your meeting data

Step 2: Configure Environment

set -euo pipefail
# Create .env file (NEVER commit to git)
echo 'FIREFLIES_API_KEY=your-api-key-here' >> .env

# Add to .gitignore
echo '.env' >> .gitignore
echo '.env.local' >> .gitignore

Step 3: Install GraphQL Client (Optional)

set -euo pipefail
# Node.js -- graphql-request is lightweight and typed
npm install graphql-request graphql

# Or use plain fetch -- no library needed
# Python -- use requests
pip install requests

Step 4: Verify Connection

// verify-fireflies.ts
const FIREFLIES_API = "https://api.fireflies.ai/graphql";

async function verifyConnection() {
  const query = `{ user { name email is_admin } }`;

  const response = await fetch(FIREFLIES_API, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      Authorization: `Bearer ${process.env.FIREFLIES_API_KEY}`,
    },
    body: JSON.stringify({ query }),
  });

  const result = await response.json();

  if (result.errors) {
    throw new Error(`Auth failed: ${result.errors[0].message}`);
  }

  const user = result.data.user;
  console.log(`Connected as: ${user.name} (${user.email})`);
  console.log(`Admin: ${user.is_admin}`);
  return user;
}

verifyConnection().catch(console.error);

Step 5: Verify with cURL

set -euo pipefail
curl -s -X POST https://api.fireflies.ai/graphql \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $FIREFLIES_API_KEY" \
  -d '{"query": "{ user { name email } }"}&#

                

              

                
                  
                  fireflies-local-dev-loop
                  View full skill →
                
                
                  Configure local development workflow for Fireflies.
                  
                      ReadWriteEditBash(npm:*)Bash(pnpm:*)Grep
                    
                
                
                  Fireflies.ai Local Dev Loop
Overview
Set up a fast local development workflow for Fireflies.ai integrations: project structure, mock data for offline development, test helpers, and API response recording for replay.
Examples
Create a fixture containing fictional speakers, an opaque meeting ID, and a short invented action item. Verify tests pass with network access disabled and that the fixture contains no real participant names, transcript text, recordings, or credentials. Store raw recordings nowhere in the repository.
Prerequisites

Completed fireflies-install-auth setup
Node.js 18+ with npm/pnpm
Vitest for testing

Instructions
Step 1: Project Structure

my-fireflies-app/
  src/
    lib/
      fireflies-client.ts    # GraphQL client (see fireflies-sdk-patterns)
      transcript-service.ts  # Business logic layer
    types/
      fireflies.ts           # TypeScript interfaces
  tests/
    fixtures/
      transcript.json        # Recorded API responses
    fireflies-client.test.ts
    transcript-service.test.ts
  .env.local                 # FIREFLIES_API_KEY (git-ignored)
  .env.example               # Template without secrets

Step 2: Record Real API Responses as Fixtures

// scripts/record-fixtures.ts
import { FirefliesClient } from "../src/lib/fireflies-client";
import { writeFileSync, mkdirSync } from "fs";

async function recordFixtures() {
  const client = new FirefliesClient();
  mkdirSync("tests/fixtures", { recursive: true });

  // Record user
  const user = await client.query(`{ user { name email user_id is_admin } }`);
  writeFileSync("tests/fixtures/user.json", JSON.stringify(user, null, 2));

  // Record transcript list
  const list = await client.query(`{
    transcripts(limit: 3) {
      id title date duration organizer_email
      summary { overview action_items keywords }
    }
  }`);
  writeFileSync("tests/fixtures/transcripts.json", JSON.stringify(list, null, 2));

  // Record single transcript with sentences
  const id = list.transcripts[0]?.id;
  if (id) {
    const full = await client.query(`
      query($id: String!) {
        transcript(id: $id) {
          id title date duration
          speakers { id name }
          sentences { speaker_name text start_time end_time }
          summary { overview action_items keywords }
          analytics {
            sentiments { positive_pct negative_pct neutral_pct }
            speakers { name duration word_count }
          }
        }
      }
    `, { id });
    writeFileSync("tests/fixtures/transcript-full.json", JSON.stringify(full, null, 2));
  }

  console.log("Fixtures recorded in tests/fixtures/");
}

recordFixtures().catch(console.error);

Step 3: Mock Client for Tests
<
                
              

                
                  
                  fireflies-migration-deep-dive
                  View full skill →
                
                
                  Migrate to Fireflies.
                  
                      ReadWriteEditBash(npm:*)Bash(curl:*)
                    
                
                
                  Fireflies.ai Migration Deep Dive
Current State
!npm list graphql graphql-request 2>/dev/null || echo 'No graphql packages'
Overview
Migrate to Fireflies.ai from other transcription platforms or custom recording systems. Covers historical recording import via uploadAudio, adapter pattern for gradual cutover, and data validation post-migration.
Prerequisites

A lawful/authorized migration scope, documented consent and retention requirements, and named data owners.
An inventory of recordings, transcripts, access rules, and deletion obligations; use synthetic fixtures for migration tests.
A staged cutover plan with rollback, reconciliation, and a restricted evidence location.

Examples
Import a fictitious recording into staging, validate only approved metadata and derived action-item fields, and compare aggregate record counts with the source inventory. Disable the canary and retain the old path if consent, access, retention, or mapping checks fail.
Migration Types

Scenario
Approach
Timeline


Fresh start (no history)
Configure Fireflies bot, done
1 day


Import recordings
Batch uploadAudio
1-2 weeks


Switch from competitor
Parallel run + gradual cutover
2-4 weeks


Enterprise rollout
Phased department-by-department
1-2 months


Instructions
Step 1: Pre-Migration Assessment

// Inventory your current meeting data
interface MigrationInventory {
  totalRecordings: number;
  totalHours: number;
  formats: string[];        // mp3, mp4, wav, m4a, ogg
  averageDuration: number;  // minutes
  dateRange: { oldest: string; newest: string };
  platforms: string[];      // Zoom, Teams, etc.
}

// Fireflies supports: mp3, mp4, wav, m4a, ogg
// Size limits: 200MB audio, 100MB video (free), 1.5GB video (paid)
// Minimum: 50KB (can bypass with bypass_size_check: true)

Step 2: Batch Upload Historical Recordings

const FIREFLIES_API = "https://api.fireflies.ai/graphql";

interface UploadJob {
  url: string;        // Must be publicly accessible HTTPS URL
  title: string;
  attendees?: { displayName: string; email: string }[];
  referenceId: string; // Your internal ID for tracking
}

async function batchUpload(jobs: UploadJob[]) {
  const results: { id: string; status: string; error?: string }[] = [];

  for (const job of jobs) {
    try {
      const res = await fetch(FIREFLIES_API, {
        method: "POST",
        headers: {
          "Content-Type": "application/json",
          Authorization: `Bearer ${process.env.FIREFLIES_API_KEY}`,

                

              

                
                  
                  fireflies-multi-env-setup
                  View full skill →
                
                
                  Configure Fireflies.
                  
                      ReadWriteEditBash(gcloud:*)
                    
                
                
                  Fireflies.ai Multi-Environment Setup
Overview
Configure Fireflies.ai with isolated API keys, webhook URLs, and settings per environment. Each environment gets its own Fireflies workspace or API key to prevent cross-environment data leakage.
Prerequisites

Separate environment identities, secret-manager references, webhook endpoints, budgets, and responsible owners.
A guard that prevents development or pull-request jobs from reaching production workspaces or transcript destinations.
Synthetic fixtures and a rollback test for environment configuration changes.

Examples
Send a fictional transcript event to staging and verify its secret, storage, and webhook route cannot access production. Rotate the staging secret, confirm the old credential is denied, and record the change without including any key or transcript content.
Environment Strategy

Environment
API Key
Webhook URL
Settings


Development
FIREFLIES_API_KEY_DEV
localhost (ngrok)
Debug logs, no cache


Staging
FIREFLIES_API_KEY_STAGING
staging.app.com/webhooks
Prod-like, short cache


Production
FIREFLIES_API_KEY_PROD
app.com/webhooks
Hardened, long cache


Instructions
Step 1: Environment Configuration Module

// config/fireflies.ts
interface FirefliesConfig {
  apiKey: string;
  apiUrl: string;
  webhookSecret: string;
  cache: { enabled: boolean; ttlSeconds: number };
  debug: boolean;
  timeout: number;
  maxRetries: number;
}

const configs: Record<string, Partial<FirefliesConfig>> = {
  development: {
    apiKey: process.env.FIREFLIES_API_KEY_DEV || "",
    webhookSecret: process.env.FIREFLIES_WEBHOOK_SECRET_DEV || "dev-secret-16char",
    cache: { enabled: false, ttlSeconds: 60 },
    debug: true,
    timeout: 30000,
    maxRetries: 1,
  },
  staging: {
    apiKey: process.env.FIREFLIES_API_KEY_STAGING || "",
    webhookSecret: process.env.FIREFLIES_WEBHOOK_SECRET_STAGING || "",
    cache: { enabled: true, ttlSeconds: 300 },
    debug: false,
    timeout: 15000,
    maxRetries: 3,
  },
  production: {
    apiKey: process.env.FIREFLIES_API_KEY_PROD || "",
    webhookSecret: process.env.FIREFLIES_WEBHOOK_SECRET_PROD || "",
    cache: { enabled: true, ttlSeconds: 3600 },
    debug: false,
    timeout: 10000,
    maxRetries: 5,
  },
};

function detectEnvironment(): string {
  if (process.env.NODE_ENV === "production") return "production";
  if (process.env.NODE_ENV === "staging" || process.env.VERCEL_ENV === "preview") return "staging";
  return "development&q

                

              

                
                  
                  fireflies-observability
                  View full skill →
                
                
                  Monitor Fireflies.
                  
                      ReadWriteEdit
                    
                
                
                  Fireflies.ai Observability
Overview
Monitor Fireflies.ai integration health: API connectivity, webhook delivery, transcript processing latency, and seat utilization. Built for Prometheus/Grafana but adaptable to any metrics system.
Examples
Send a synthetic webhook through the processing path and confirm dashboards show an opaque event ID, delivery latency, and aggregate status only. Trigger a controlled failure to verify the alert fires with no transcript text, participant identity, recording link, or credential in the payload.
Prerequisites

Fireflies Business+ plan (for full API access)
Prometheus + Grafana (or equivalent metrics stack)
Webhook endpoint deployed and receiving events

Instructions
Step 1: Instrument the GraphQL Client

// lib/fireflies-instrumented.ts
import { Counter, Histogram, Gauge } from "prom-client";

const apiRequests = new Counter({
  name: "fireflies_api_requests_total",
  help: "Total Fireflies API requests",
  labelNames: ["operation", "status"],
});

const apiLatency = new Histogram({
  name: "fireflies_api_latency_seconds",
  help: "Fireflies API request latency",
  labelNames: ["operation"],
  buckets: [0.1, 0.25, 0.5, 1, 2, 5, 10],
});

const FIREFLIES_API = "https://api.fireflies.ai/graphql";

export async function firefliesQueryInstrumented(
  operation: string,
  query: string,
  variables?: any
) {
  const timer = apiLatency.startTimer({ operation });

  try {
    const res = await fetch(FIREFLIES_API, {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        Authorization: `Bearer ${process.env.FIREFLIES_API_KEY}`,
      },
      body: JSON.stringify({ query, variables }),
    });

    const json = await res.json();

    if (json.errors) {
      apiRequests.inc({ operation, status: json.errors[0].code || "error" });
      throw new Error(json.errors[0].message);
    }

    apiRequests.inc({ operation, status: "success" });
    return json.data;
  } catch (err) {
    apiRequests.inc({ operation, status: "failure" });
    throw err;
  } finally {
    timer();
  }
}

Step 2: Webhook Event Metrics

const webhookEvents = new Counter({
  name: "fireflies_webhook_events_total",
  help: "Webhook events received",
  labelNames: ["event_type", "status"],
});

const webhookProcessingTime = new Histogram({
  name: "fireflies_webhook_processing_seconds",
  help: "Time to process webhook events",
  buckets: [0.1, 0.5, 1, 5, 10, 30],
});

const transcriptQueue = new Gauge({
  name: "fireflies_transcript_queue_depth",
  help: "Number of transcripts queued for processing",

                

              

                
                  
                  fireflies-performance-tuning
                  View full skill →
                
                
                  Optimize Fireflies.
                  
                      ReadWriteEdit
                    
                
                
                  Fireflies.ai Performance Tuning
Overview
Optimize Fireflies.ai GraphQL API performance. The biggest wins: request only needed fields (transcripts with sentences can be very large), cache immutable transcripts, and batch operations within rate limits.
Examples
Benchmark a synthetic transcript query using only an opaque ID and aggregate field counts, then enable a short-lived cache in staging. Verify the cache respects access and retention rules, an unauthorized consumer is denied, and metrics do not contain transcript text or speaker names.
Prerequisites

FIREFLIES_API_KEY configured
Understanding of your access pattern (list vs detail, frequency)
Optional: Redis or LRU cache library

Instructions
Step 1: Field Selection -- The Biggest Win
Transcript responses with sentences can be enormous. Always request the minimum fields needed.

// BAD: Fetching everything when you only need titles
const HEAVY = `{ transcripts(limit: 50) {
  id title date duration sentences { text speaker_name start_time end_time }
  summary { overview action_items keywords outline bullet_gist }
  analytics { speakers { name duration word_count } }
} }`;

// GOOD: Light query for listing
const LIGHT = `{ transcripts(limit: 50) {
  id title date duration organizer_email
} }`;

// GOOD: Full query only when drilling into a specific transcript
const DETAIL = `query($id: String!) { transcript(id: $id) {
  id title
  sentences { speaker_name text start_time end_time }
  summary { overview action_items keywords }
} }`;

Step 2: Cache Transcripts (They Are Immutable)
Once a transcript is processed, its content never changes. Cache aggressively.

import { LRUCache } from "lru-cache";

const transcriptCache = new LRUCache<string, any>({
  max: 500,
  ttl: 1000 * 60 * 60, // 1 hour -- transcripts are immutable
});

async function getCachedTranscript(id: string) {
  const cached = transcriptCache.get(id);
  if (cached) return cached;

  const data = await firefliesQuery(`
    query($id: String!) {
      transcript(id: $id) {
        id title date duration
        speakers { name }
        sentences { speaker_name text start_time end_time }
        summary { overview action_items keywords }
      }
    }
  `, { id });

  transcriptCache.set(id, data.transcript);
  return data.transcript;
}

Step 3: Redis Cache for Multi-Instance Deployments

import Redis from "ioredis";

const redis = new Redis(process.env.REDIS_URL!);
const CACHE_TTL = 3600; // 1 hour in seconds

async function getTranscriptCached(id: string) {
  const cacheKey = `fireflies:transcript:${id}`;

  // Check cache
  const cached = await redis.get(cacheKey);
  if (cached) return JSON.parse(cached);

  // Fetch from

                

              

                
                  
                  fireflies-prod-checklist
                  View full skill →
                
                
                  Execute Fireflies.
                  
                      ReadBash(curl:*)Grep
                    
                
                
                  Fireflies.ai Production Checklist
Overview
Complete checklist for deploying Fireflies.ai integrations to production. Covers API key management, webhook setup, health checks, and monitoring.
Instructions

Attach evidence or an owner decision to every applicable checklist control, including consent/access boundaries and retention behavior.
Verify scoped secrets, signature validation, idempotent processing, redacted telemetry, and a tested rollback before production promotion.
Run a canary with a fictional meeting event, observe aggregate health and delivery state, then stop promotion on any permission, destination, or safety failure.
Record the launch, rollback owner, exceptions, and final approver in the production receipt.

Examples
Process a synthetic transcript-ready event through staging, revoke a test recipient’s access, and verify no replay occurs after a simulated worker failure. Promote only when the approver records canary evidence and all required controls have a verified owner.
Prerequisites

Staging environment tested
Production API key from Fireflies dashboard
Webhook endpoint with HTTPS and signature verification
Monitoring infrastructure ready

Pre-Deployment Checklist
API & Auth

[ ] Production FIREFLIES_API_KEY in secret manager (not env file)
[ ] API key has minimum required access
[ ] FIREFLIES_WEBHOOK_SECRET configured (16-32 chars)
[ ] Separate keys for dev/staging/prod environments
[ ] Key rotation procedure documented

Code Quality

[ ] All GraphQL queries tested against real API in staging
[ ] Error handling for all Fireflies error codes (auth_failed, too_many_requests, require_ai_credits)
[ ] Rate limiting with exponential backoff implemented
[ ] No hardcoded API keys or transcript IDs
[ ] Webhook signature verification (HMAC-SHA256) enabled

Webhook Configuration

[ ] Webhook URL registered in Fireflies dashboard (Settings > Developer settings)
[ ] HTTPS endpoint with valid TLS certificate
[ ] x-hub-signature header verified on every request
[ ] Webhook handler responds with 200 immediately (process async)
[ ] Dead-letter queue for failed webhook processing

Health Check Endpoint

// /api/health
export async function GET() {
  const checks: Record<string, any> = {};

  // Fireflies API connectivity
  try {
    const start = Date.now();
    const res = await fetch("https://api.fireflies.ai/graphql", {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        Authorization: `Beare

                

              

                
                  
                  fireflies-rate-limits
                  View full skill →
                
                
                  Implement Fireflies.
                  
                      ReadWriteEdit
                    
                
                
                  Fireflies.ai Rate Limits
Overview
Handle Fireflies.ai GraphQL API rate limits with exponential backoff and request queuing. Fireflies enforces per-plan limits and per-operation limits.
Prerequisites

Current provider limits confirmed for the account, plus an approved concurrency, retry bound, and queue owner.
Aggregate telemetry that omits transcript content, participant information, and authorization data.
Synthetic meeting fixtures for testing pauses, retries, and duplicate suppression.

Examples
Queue two synthetic transcript summaries under one idempotency key and simulate a throttle response. The worker backs off within its bound, processes the item once after recovery, and routes an exhausted retry to review without logging transcript text.
Rate Limit Reference
Per-Plan Limits

Plan
Limit
Scope


Free
50 requests/day
Per API key


Pro
50 requests/day
Per API key


Business
60 requests/min
Per API key


Enterprise
60 requests/min
Per API key


Per-Operation Limits

Operation
Limit
Error Code


addToLiveMeeting
3 per 20 minutes
too_many_requests


shareMeeting
10 per hour (up to 50 emails each)
too_many_requests


deleteTranscript
10 per minute
too_many_requests


uploadAudio
Varies by plan
too_many_requests


Instructions
Step 1: Detect Rate Limits in Responses

interface FirefliesError {
  message: string;
  code: string;
  extensions?: { status: number };
}

function isRateLimited(response: any): boolean {
  return response.errors?.some(
    (e: FirefliesError) =>
      e.code === "too_many_requests" ||
      e.extensions?.status === 429
  );
}

Step 2: Exponential Backoff with Jitter

async function firefliesQueryWithRetry<T>(
  query: string,
  variables?: Record<string, any>,
  maxRetries = 5
): Promise<T> {
  const FIREFLIES_API = "https://api.fireflies.ai/graphql";

  for (let attempt = 0; attempt <= maxRetries; attempt++) {
    const res = await fetch(FIREFLIES_API, {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        Authorization: `Bearer ${process.env.FIREFLIES_API_KEY}`,
      },
      body: JSON.stringify({ query, variables }),
    });

    const json = awa

                

              

                
                  
                  fireflies-reference-architecture
                  View full skill →
                
                
                  Design meeting intelligence architecture with Fireflies.
                  
                      ReadGrep
                    
                
                
                  Fireflies.ai Reference Architecture
Overview
Production architecture for meeting intelligence using Fireflies.ai. Event-driven pipeline: meetings are recorded by the Fireflies bot, transcripts arrive via webhook, then are processed for action items, analytics, and CRM sync.
Prerequisites

A documented consent, access, retention, and downstream-sharing policy for each meeting source.
Scoped identities separating webhook ingress, transcript processing, storage, and CRM consumers.
A policy owner, synthetic fixtures, redacted telemetry, and an emergency disable/rollback path.

Instructions

Verify event signatures at ingress and place opaque IDs on a durable, idempotent queue.
Retrieve and process transcript data only within the authorized worker; apply field allowlists before any downstream sync.
Enforce retention and access checks at storage and retrieval, and emit aggregate/redacted operational metrics.
Test with fictional meetings, promote through a canary, and stop processing if consent, access, or destination validation fails.

Examples
Route a synthetic transcript-ready event through the queue using an opaque ID. The worker writes only approved action items to a staging CRM, rejects a repeated event as a duplicate, and records no transcript text in logs or metrics.
Architecture

┌──────────────────────────────────────────────────────┐
│              Meeting Sources                          │
│  Zoom  │  Google Meet  │  MS Teams  │  Upload API    │
└──────────┬───────────────────────────────┬───────────┘
           │ Bot auto-joins                │ uploadAudio
           ▼                               ▼
┌──────────────────────────────────────────────────────┐
│              Fireflies.ai Platform                    │
│  Transcription → Speaker ID → AI Summary → Actions   │
└───────────────────────┬──────────────────────────────┘
                        │ Webhook: "Transcription completed"
                        │ Payload: { meetingId, eventType }
                        ▼
┌──────────────────────────────────────────────────────┐
│              Your Webhook Receiver                    │
│  1. Verify x-hub-signature (HMAC-SHA256)             │
│  2. ACK 200 immediately                              │
│  3. Queue for async processing                       │
└───────────────────────┬──────────────────────────────┘
                        │
           ┌────────────┼────────────┐
           ▼            ▼            ▼
   ┌──────────────┐ ┌────────┐ ┌──────────────┐
   │ Transcript   │ │ Action │ │ Analytics    │
   │ Storage      │ │ Items  │ │ Engine       │
   │ (DB/Search)  │ │ (CRM)  │ │ (Dashboards) │
   └──────────────┘ └────────┘ └──────────────┘

Core Components
1. GraphQL Client Layer

// lib/fireflies.ts
const 

                

              

                
                  
                  fireflies-sdk-patterns
                  View full skill →
                
                
                  Apply production-ready Fireflies.
                  
                      ReadWriteEdit
                    
                
                
                  Fireflies.ai Client Patterns
Overview
Production-ready patterns for the Fireflies.ai GraphQL API. Fireflies has no official SDK -- all interaction is via HTTP POST to https://api.fireflies.ai/graphql. These patterns provide typed wrappers, error handling, caching, and multi-tenant support.
Examples
Use a scoped staging credential to query a synthetic meeting record and return only an opaque meeting ID plus a schema-validation result. Confirm application logs redact authorization headers and transcript text, then revoke the test credential before connecting to any production workspace.
Prerequisites

FIREFLIES_API_KEY environment variable set
TypeScript 5+ or Python 3.10+
Optional: graphql-request for typed queries

Instructions
Step 1: Typed GraphQL Client (TypeScript)

// lib/fireflies-client.ts
const FIREFLIES_API = "https://api.fireflies.ai/graphql";

interface FirefliesError {
  message: string;
  code?: string;
  extensions?: { status: number; helpUrls?: string[] };
}

interface FirefliesResponse<T> {
  data?: T;
  errors?: FirefliesError[];
}

export class FirefliesClient {
  private apiKey: string;
  private baseUrl: string;

  constructor(apiKey?: string) {
    this.apiKey = apiKey || process.env.FIREFLIES_API_KEY!;
    this.baseUrl = FIREFLIES_API;
    if (!this.apiKey) throw new Error("FIREFLIES_API_KEY is required");
  }

  async query<T = any>(gql: string, variables?: Record<string, any>): Promise<T> {
    const res = await fetch(this.baseUrl, {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        Authorization: `Bearer ${this.apiKey}`,
      },
      body: JSON.stringify({ query: gql, variables }),
    });

    const json: FirefliesResponse<T> = await res.json();

    if (json.errors?.length) {
      const err = json.errors[0];
      const error = new Error(`Fireflies: ${err.message}`) as any;
      error.code = err.code;
      error.status = err.extensions?.status;
      throw error;
    }

    return json.data!;
  }

  // Convenience methods for common queries
  async getUser() {
    return this.query<{ user: any }>(`{ user { name email user_id is_admin } }`);
  }

  async getTranscripts(limit = 20) {
    return this.query<{ transcripts: any[] }>(`
      query($limit: Int) {
        transcripts(limit: $limit) {
          id title date duration organizer_email participants
          summary { overview action_items keywords }
        }
      }
    `, { limit });
  }

  async getTranscript(id: string) {
    return this.query<{ transcript: any }>(`
      query($id: String!) {
        transcript(id: $id) {
          id title date duration
          speakers { id name }
          sentences { speaker_name text start_time end_time }

                

              

                
                  
                  fireflies-security-basics
                  View full skill →
                
                
                  Apply Fireflies.
                  
                      ReadWriteGrep
                    
                
                
                  Fireflies.ai Security Basics
Overview
Security essentials for Fireflies.ai: API key management, webhook HMAC-SHA256 signature verification, transcript access controls, and audit practices.
Examples
Use a scoped staging key and a synthetic signed webhook event. Confirm invalid signatures are rejected without logging the body, access is limited to the approved test channel, and revoking the key immediately blocks further requests. Record only redacted control evidence.
Prerequisites

Fireflies.ai API key
Understanding of environment variables
HTTPS endpoint for webhooks (required by Fireflies)

Instructions
Step 1: Secure API Key Storage

# .env (NEVER commit)
FIREFLIES_API_KEY=your-api-key
FIREFLIES_WEBHOOK_SECRET=your-16-to-32-char-secret

# .gitignore
.env
.env.local
.env.*.local

Pre-commit hook to catch leaked keys:

#!/bin/bash
# .git/hooks/pre-commit
if git diff --cached --name-only | xargs grep -l 'FIREFLIES_API_KEY\s*=' 2>/dev/null; then
  echo "ERROR: Potential API key in commit. Remove before committing."
  exit 1
fi

Step 2: Webhook Signature Verification (HMAC-SHA256)
Fireflies signs webhook payloads with HMAC-SHA256. The signature arrives in the x-hub-signature header.

import crypto from "crypto";

function verifyFirefliesWebhook(
  payload: string,
  signature: string,
  secret: string
): boolean {
  const expected = crypto
    .createHmac("sha256", secret)
    .update(payload)
    .digest("hex");

  // Timing-safe comparison prevents timing attacks
  return crypto.timingSafeEqual(
    Buffer.from(signature),
    Buffer.from(expected)
  );
}

// Express middleware
import express from "express";
const app = express();

app.post("/webhooks/fireflies",
  express.raw({ type: "application/json" }),
  (req, res) => {
    const signature = req.headers["x-hub-signature"] as string;
    const payload = req.body.toString();

    if (!signature || !verifyFirefliesWebhook(payload, signature, process.env.FIREFLIES_WEBHOOK_SECRET!)) {
      console.warn("Invalid webhook signature rejected");
      return res.status(401).json({ error: "Invalid signature" });
    }

    const event = JSON.parse(payload);
    console.log(`Verified webhook: ${event.eventType} for ${event.meetingId}`);
    res.status(200).json({ received: true });
  }
);

Step 3: Configure Webhook Secret

Go to app.fireflies.ai/settings
Select Developer settings tab
Enter a 16-32 character secret or click Generate
Store the secret in your environment as FIREFLIES

                

              

                
                  
                  fireflies-upgrade-migration
                  View full skill →
                
                
                  Handle Fireflies.
                  
                      ReadWriteEditBash(npm:*)Bash(curl:*)Grep
                    
                
                
                  Fireflies.ai Upgrade & Migration
Current State
!npm list graphql graphql-request 2>/dev/null || echo 'No graphql packages'
Overview
Fireflies.ai uses a GraphQL API (no versioned SDK). Breaking changes come as field deprecations and new query parameter patterns. This skill covers all known deprecations and migration paths.
Prerequisites

Current provider change information and an inventory of queries, downstream consumers, retention rules, and access scopes.
Staging credentials, synthetic meeting fixtures, a rollback owner, and an acceptance checklist for schema and permission behavior.

Instructions

Identify each deprecated field/query and classify it as compatible, transformed, removed, or unknown.
Update one mapping at a time in staging with fictional data; keep the prior query available through reconciliation.
Verify access controls, transcript minimization, idempotent delivery, and expected error handling before a small canary.
Compare aggregate results, obtain the owner’s approval, and roll back immediately on schema, permission, or retention mismatch.

Examples
Run the old and proposed query against a synthetic transcript, compare only schema-valid fields and aggregate counts, and introduce an unauthorized field deliberately. The canary must reject the extra field and retain the prior query until the mapping review is approved.
Known Deprecations
Transcript Query Parameter Changes

// DEPRECATED: Single organizer email string
const OLD = `{ transcripts(organizer_email: "alice@co.com") { id } }`;

// CURRENT: Array of organizer emails
const NEW = `{ transcripts(organizers: ["alice@co.com"]) { id } }`;


// DEPRECATED: Single participant email string
const OLD = `{ transcripts(participant_email: "bob@co.com") { id } }`;

// CURRENT: Array of participant emails
const NEW = `{ transcripts(participants: ["bob@co.com"]) { id } }`;


// DEPRECATED: title parameter for search
const OLD = `{ transcripts(title: "standup") { id } }`;

// CURRENT: keyword with scope
const NEW = `{ transcripts(keyword: "standup") { id } }`;


// DEPRECATED: date parameter (single date)
const OLD = `{ transcripts(date: "2026-03-01") { id } }`;

// CURRENT: fromDate/toDate range
const NEW = `{
  transcripts(
    fromDate: "2026-03-01T00:00:00Z"
    toDate: "2026-03-31T23:59:59Z"
  ) { id }
}`;

Field-Level Deprecations

// DEPRECATED
transcript.host_email

// CURRENT
transcript.organizer_email

Migration Procedure
Step 1: Scan Codebase for D
                
              

                
                  
                  fireflies-webhooks-events
                  View full skill →
                
                
                  Implement Fireflies.
                  
                      ReadWriteEditBash(curl:*)
                    
                
                
                  Fireflies.ai Webhooks & Events
Overview
Handle Fireflies.ai webhook events for real-time transcript notifications. Fireflies fires a webhook when a transcript finishes processing. The payload is signed with HMAC-SHA256 for verification.
Examples
Deliver the same synthetic signed transcript-ready event twice. The handler verifies the raw-body signature, stores an opaque event ID, processes only the first event, and emits a duplicate receipt for the second. An invalid signature must be rejected without logging the transcript identifier or payload.
Prerequisites

Fireflies.ai Business or Enterprise plan
FIREFLIES_API_KEY and FIREFLIES_WEBHOOK_SECRET in environment
HTTPS endpoint accessible from the internet

Webhook Event Reference
Fireflies currently fires one event type:

Event
eventType Value
Trigger


Transcription completed
"Transcription completed"
Transcript is fully processed and ready


Payload Format

{
  "meetingId": "ASxwZxCstx",
  "eventType": "Transcription completed",
  "clientReferenceId": "be582c46-4ac9-4565-9ba6-6ab4264496a8"
}


Field
Type
Description


meetingId
String
Transcript ID -- use in transcript(id:) query


eventType
String
Always "Transcription completed" currently


clientReferenceId
ID
Your custom ID from uploadAudio (null if bot-recorded)


Important Constraints

Webhooks fire only for meetings you own (organizer_email matches your account)
Super Admin webhooks (Enterprise only) fire for all team-owned meetings

Instructions
Step 1: Register Webhook in Dashboard

Go to app.fireflies.ai/settings
Select Developer settings tab
Enter your HTTPS webhook URL
Enter or generate a 16-32 character secret
Save

Step 2: Build Webhook Receiver with Signature Verification

import express from "express";
import crypto from "crypto";

const app = express();

// IMPORTANT: Use raw body for HMAC verification
app.post("/webhooks/fireflies",
  express.raw({ type: "application/json" }),
  async (req, res) => {
    const signature = req.headers["x-hub-signature"] as string;
    const rawBody = req.b

                

              

          

        

      
      
          How It Works
          Skills trigger automatically when you discuss Fireflies.ai topics:

"Help me set up the Fireflies API" -- triggers fireflies-install-auth
"Fetch my recent meeting transcripts" -- triggers fireflies-core-workflow-a
"Search meetings for quarterly review" -- triggers fireflies-core-workflow-b
"Set up a webhook for transcript notifications" -- triggers fireflies-webhooks-events
"Upload a recording to Fireflies" -- triggers fireflies-migration-deep-dive
"Ask Fred about my last meeting" -- triggers fireflies-core-workflow-b

        

      
      

      
      

      
      
  Ready to use fireflies-pack?
  
    
    
  




      
      
          Related Plugins
          
            
  supabase-pack
  Complete Supabase integration skill pack with 30 skills covering authentication, database, storage, realtime, edge functions, and production operations. Flagship+ tier vendor pack.
  /plugin install supabase-pack@claude-code-plugins-plus
  

  vercel-pack
  Complete Vercel integration skill pack with 30 skills covering deployments, edge functions, preview environments, performance optimization, and production operations. Flagship+ tier vendor pack.
  /plugin install vercel-pack@claude-code-plugins-plus
  

  clay-pack
  Complete Clay integration skill pack with 30 skills covering data enrichment, waterfall workflows, AI agents, and GTM automation. Flagship+ tier vendor pack.
  /plugin install clay-pack@claude-code-plugins-plus
  

  cursor-pack
  Complete Cursor integration skill pack with 30 skills covering AI code editing, composer workflows, codebase indexing, and productivity features. Flagship+ tier vendor pack.
  /plugin install cursor-pack@claude-code-plugins-plus
  

  exa-pack
  Complete Exa integration skill pack with 30 skills covering neural search, semantic retrieval, web search API, and AI-powered discovery. Flagship+ tier vendor pack.
  /plugin install exa-pack@claude-code-plugins-plus
  

  firecrawl-pack
  Complete Firecrawl integration skill pack with 30 skills covering web scraping, crawling, markdown conversion, and LLM-ready data extraction. Flagship+ tier vendor pack.
  /plugin install firecrawl-pack@claude-code-plugins-plus
  

          
        

      
      
          Tags
          
            firefliesmeeting-transcriptionai-notesconversation-intelligencesummaries
          
        
    
  

  

    

    
    
        
            
                Agent Skills in Your Inbox
                
                    
                    
                    
                
                No spam, ever. Unsubscribe with one click.
            

            
                
                    Product
                    
                        Explore
                        Skills
                        Cowork
                        Compare
                        Tools
                    
                
                
                    Resources
                    
                        Docs
                        Changelog
                        Collections
                        Playbooks
                        Research
                        Learning
                    
                
                
                    Company
                    
                        Community
                        Hall of Fame
                        GitHub
                    
                
                
                    Legal
                    
                        Privacy
                        Terms
                        Acceptable Use
                    
                
            

            
            

            
                Tons of Skills by Intent Solutions. Open-source plugins, agents and skills for AI coding agents.
                © 2026 Tons of Skills | Intent Solutions