diff --git a/integrations/fireflies-conversations/README.md b/integrations/fireflies-conversations/README.md
new file mode 100644
index 000000000..f5ced0c90
--- /dev/null
+++ b/integrations/fireflies-conversations/README.md
@@ -0,0 +1,78 @@
+# Fireflies Conversations Integration
+
+This integration allows GitBook to ingest meeting transcripts from Fireflies to provide AI-suggested improvements to your documentation.
+
+## Features
+
+- **Bulk Transcript Import**: When first installed, the integration fetches recent transcripts from Fireflies (last 30 days)
+- **Real-time Webhook Ingestion**: Automatically ingests transcripts when transcription completes via webhooks
+- **Automatic Conversion**: Converts Fireflies transcripts into GitBook conversations format for analysis
+
+## Setup
+
+1. Install the integration in your GitBook organization
+2. Enter your Fireflies API key in the integration settings
+3. The integration will automatically start ingesting transcripts from the last 30 days
+
+## Webhook Setup (Optional)
+
+To enable real-time transcript ingestion when transcription completes:
+
+1. **Configure Webhook Secret**:
+   - In the GitBook integration settings, enter your Fireflies webhook secret
+   - You can find or generate this in your Fireflies dashboard: Settings → Developer Settings
+   - The webhook secret is used to verify that webhook requests are authentic
+
+2. **Configure Webhook URL in Fireflies**:
+   - Visit [Fireflies.ai dashboard settings](https://app.fireflies.ai/settings)
+   - Navigate to the Developer settings tab
+   - Enter your webhook URL: `https://[your-integration-endpoint]/webhook`
+   - The webhook URL can be found in your GitBook integration settings
+   - Save the webhook URL
+
+3. **Test the Webhook**:
+   - Upload an audio file through the Fireflies dashboard at [app.fireflies.ai/upload](https://app.fireflies.ai/upload)
+   - Once transcription completes, the webhook should trigger and the transcript will be automatically ingested into GitBook
+
+**Note**: Webhooks are only fired for meetings that you own (the `organizer_email`). For team-wide webhooks, you need the Enterprise tier with Super Admin role.
+
+## Getting Your Fireflies API Key
+
+1. Log in to your Fireflies account
+2. Navigate to Settings → Integrations → API
+3. Generate or copy your API key
+4. Paste the API key into the GitBook integration configuration
+
+## Development
+
+To develop and test this integration, you'll need a Fireflies API key:
+
+### 1. Get a Fireflies API Key
+
+1. Go to [Fireflies](https://fireflies.ai/) and log in to your account
+2. Navigate to Settings → Integrations → API
+3. Generate an API key if you don't have one
+
+### 2. Testing
+
+The integration uses the Fireflies GraphQL API to fetch transcripts. You can test the integration by:
+
+1. Setting up the integration with your API key
+2. Verifying that transcripts are fetched and converted to GitBook conversations
+3. Checking that the conversation parts are properly formatted with speaker information
+
+### 3. Webhook Testing
+
+To test webhook functionality:
+
+1. Set up the integration with your API key and webhook secret
+2. Configure the webhook URL in your Fireflies dashboard
+3. Upload an audio file or wait for a meeting to be transcribed
+4. Verify that the transcript is automatically ingested when transcription completes
+
+### 4. API Documentation
+
+For more information about the Fireflies APIs, see:
+- [Fireflies GraphQL API Documentation](https://docs.fireflies.ai/graphql-api/query/transcripts)
+- [Fireflies Webhooks Documentation](https://docs.fireflies.ai/graphql-api/webhooks)
+
diff --git a/integrations/fireflies-conversations/assets/hubspot-preview.png b/integrations/fireflies-conversations/assets/hubspot-preview.png
new file mode 100644
index 000000000..9e66370ac
Binary files /dev/null and b/integrations/fireflies-conversations/assets/hubspot-preview.png differ
diff --git a/integrations/fireflies-conversations/assets/logo.png b/integrations/fireflies-conversations/assets/logo.png
new file mode 100644
index 000000000..754e5ebc0
Binary files /dev/null and b/integrations/fireflies-conversations/assets/logo.png differ
diff --git a/integrations/fireflies-conversations/gitbook-manifest.yaml b/integrations/fireflies-conversations/gitbook-manifest.yaml
new file mode 100644
index 000000000..bc401cd7c
--- /dev/null
+++ b/integrations/fireflies-conversations/gitbook-manifest.yaml
@@ -0,0 +1,37 @@
+name: fireflies-conversations
+title: Fireflies Connector
+icon: ./assets/logo.png
+description: Automatically sync Fireflies transcripts to docs updates in GitBook.
+visibility: public
+script: ./src/index.ts
+previewImages:
+    - ./assets/hubspot-preview.png
+summary: |
+    # Overview
+
+    Connecting Fireflies to GitBook turns every meeting transcript into documentation intelligence. The integration ingests transcript data, spots recurring issues, and surfaces where your docs need to be clearer, more accurate, or more complete.
+
+    ## How it works
+
+    GitBook Agent analyzes incoming transcripts, identifies patterns, and highlights gaps in your documentation. When it finds issues, it opens proactive change requests with suggested edits, drafted improvements, and the context behind each recommendation. You can also @mention the AI agent or chat with it directly to speed up reviews and polish updates.
+
+    ## Configure
+
+    1. Add your Fireflies API key  
+       Install the GitBook app in your GitBook account, then open its settings and enter your Fireflies API key. This allows GitBook to pull transcripts and their conversation history while automatically stripping sensitive data.
+
+    2. Let the GitBook Agent learn  
+       GitBook analyzes each transcript to detect FAQs, outdated content, unclear explanations, missing troubleshooting steps, and opportunities to improve clarity.
+
+    3. Watch it open proactive change requests  
+       As patterns emerge, GitBook creates change requests with proposed edits, context from meeting transcripts, and a working draft written by the AI agent.
+
+    4. Refine with the AI agent  
+       Inside any change request, @mention the agent or open its chat panel to request rewrites, clarifications, or additions. You stay in control while the agent accelerates updates.
+scopes:
+    - conversations:ingest
+organization: gitbook
+configurations:
+    account:
+        componentId: config
+target: organization
diff --git a/integrations/fireflies-conversations/package.json b/integrations/fireflies-conversations/package.json
new file mode 100644
index 000000000..b231733cb
--- /dev/null
+++ b/integrations/fireflies-conversations/package.json
@@ -0,0 +1,20 @@
+{
+    "name": "@gitbook/integration-fireflies-conversations",
+    "version": "0.1.0",
+    "private": true,
+    "dependencies": {
+        "@gitbook/api": "*",
+        "@gitbook/runtime": "*",
+        "itty-router": "^2.6.1",
+        "p-map": "^7.0.3"
+    },
+    "devDependencies": {
+        "@gitbook/cli": "workspace:*",
+        "@gitbook/tsconfig": "workspace:*"
+    },
+    "scripts": {
+        "typecheck": "tsc --noEmit",
+        "check": "gitbook check",
+        "publish-integrations-staging": "gitbook publish .  --env staging"
+    }
+}
diff --git a/integrations/fireflies-conversations/src/client.ts b/integrations/fireflies-conversations/src/client.ts
new file mode 100644
index 000000000..ad78e3c35
--- /dev/null
+++ b/integrations/fireflies-conversations/src/client.ts
@@ -0,0 +1,71 @@
+import { ExposableError, Logger } from '@gitbook/runtime';
+import { FirefliesRuntimeContext } from './types';
+
+const logger = Logger('fireflies-conversations:client');
+
+/**
+ * Get the API key for Fireflies API calls.
+ */
+export function getFirefliesApiKey(context: FirefliesRuntimeContext): string {
+    const { installation } = context.environment;
+
+    if (!installation) {
+        throw new ExposableError('Installation not found');
+    }
+
+    const { api_key } = installation.configuration;
+    if (!api_key) {
+        throw new ExposableError(
+            'Fireflies API key not found. Please configure the API key in the integration settings.',
+        );
+    }
+
+    return api_key;
+}
+
+/**
+ * Make a GraphQL request to the Fireflies API.
+ */
+export async function firefliesGraphQLRequest<T = unknown>(
+    context: FirefliesRuntimeContext,
+    query: string,
+    variables?: Record<string, unknown>,
+): Promise<T> {
+    const apiKey = getFirefliesApiKey(context);
+
+    const response = await fetch('https://api.fireflies.ai/graphql', {
+        method: 'POST',
+        headers: {
+            Authorization: `Bearer ${apiKey}`,
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+            query,
+            variables,
+        }),
+    });
+
+    if (!response.ok) {
+        const errorText = await response.text();
+        logger.error('Fireflies API request failed', {
+            status: response.status,
+            statusText: response.statusText,
+            error: errorText,
+        });
+        throw new Error(`Fireflies API request failed: ${response.status} ${response.statusText}`);
+    }
+
+    const result = (await response.json()) as T;
+
+    // Check for GraphQL errors
+    if (result && typeof result === 'object' && 'errors' in result) {
+        const errors = (result as { errors?: Array<{ message: string }> }).errors;
+        if (errors && errors.length > 0) {
+            const errorMessage = errors.map((e) => e.message).join(', ');
+            logger.error('Fireflies GraphQL errors', { errors });
+            throw new Error(`Fireflies GraphQL error: ${errorMessage}`);
+        }
+    }
+
+    return result;
+}
diff --git a/integrations/fireflies-conversations/src/config.tsx b/integrations/fireflies-conversations/src/config.tsx
new file mode 100644
index 000000000..f7cf0e442
--- /dev/null
+++ b/integrations/fireflies-conversations/src/config.tsx
@@ -0,0 +1,132 @@
+import { createComponent, InstallationConfigurationProps } from '@gitbook/runtime';
+import { FirefliesRuntimeContext, FirefliesRuntimeEnvironment } from './types';
+
+type FirefliesConfigState = {
+    api_key: string;
+    webhook_secret: string;
+};
+
+type FirefliesConfigAction = { action: 'save.config' };
+
+/**
+ * Configuration component for the Fireflies integration.
+ */
+export const configComponent = createComponent<
+    InstallationConfigurationProps<FirefliesRuntimeEnvironment>,
+    FirefliesConfigState,
+    FirefliesConfigAction,
+    FirefliesRuntimeContext
+>({
+    componentId: 'config',
+    initialState: (props) => {
+        const installation = props.installation;
+        return {
+            api_key: installation.configuration?.api_key || '',
+            webhook_secret: installation.configuration?.webhook_secret || '',
+        };
+    },
+    action: async (element, action, context) => {
+        switch (action.action) {
+            case 'save.config':
+                const { api, environment } = context;
+                const { installation } = environment;
+
+                if (!installation) {
+                    return { type: 'complete' };
+                }
+
+                const configurationBody = {
+                    ...installation.configuration,
+                    api_key: element.state.api_key,
+                    webhook_secret: element.state.webhook_secret,
+                };
+
+                await api.integrations.updateIntegrationInstallation(
+                    environment.integration.name,
+                    installation.id,
+                    {
+                        configuration: {
+                            ...configurationBody,
+                        },
+                    },
+                );
+
+                return { type: 'complete' };
+        }
+    },
+    render: async (element, context) => {
+        const { installation } = context.environment;
+        if (!installation) {
+            return null;
+        }
+
+        const hasApiKey = !!element.props.installation.configuration?.api_key;
+        const hasWebhookSecret = !!element.props.installation.configuration?.webhook_secret;
+
+        return (
+            <configuration>
+                <input
+                    label="Fireflies API Key"
+                    hint={
+                        'Enter your Fireflies API key. You can find this in your Fireflies account settings.'
+                    }
+                    element={
+                        <textinput state="api_key" placeholder="Enter your Fireflies API key" />
+                    }
+                />
+
+                <input
+                    label="Webhook Secret"
+                    hint={
+                        'Enter your Fireflies webhook secret for verifying webhook requests. You can find or generate this in Settings → Developer Settings in your Fireflies dashboard.'
+                    }
+                    element={
+                        <textinput state="webhook_secret" placeholder="Enter your webhook secret" />
+                    }
+                />
+
+                <input
+                    label="Webhook URL"
+                    hint={
+                        <text>
+                            Add this URL to the <text style="bold">Webhooks</text> section in your{' '}
+                            <text style="bold">Developer Settings</text> in your Fireflies dashboard
+                            at{' '}
+                            <link
+                                target={{
+                                    url: 'https://app.fireflies.ai/settings',
+                                }}
+                            >
+                                app.fireflies.ai/settings
+                            </link>
+                            .
+                        </text>
+                    }
+                    element={<codeblock content={`${installation.urls.publicEndpoint}/webhook`} />}
+                />
+
+                <button
+                    label={hasApiKey ? 'Update Configuration' : 'Save Configuration'}
+                    onPress={{
+                        action: 'save.config',
+                    }}
+                />
+
+                {hasApiKey ? (
+                    <hint>
+                        <text>
+                            The integration is configured and transcripts are being ingested.
+                            {hasWebhookSecret
+                                ? ' Webhook support is enabled for real-time transcript ingestion.'
+                                : ' To enable real-time webhook ingestion, add your webhook secret and configure the webhook URL in your Fireflies dashboard.'}
+                        </text>
+                    </hint>
+                ) : (
+                    <hint>
+                        <text>Please enter your Fireflies API key to enable the integration.</text>
+                    </hint>
+                )}
+            </configuration>
+        );
+    },
+});
diff --git a/integrations/fireflies-conversations/src/conversations.ts b/integrations/fireflies-conversations/src/conversations.ts
new file mode 100644
index 000000000..cbe7cafde
--- /dev/null
+++ b/integrations/fireflies-conversations/src/conversations.ts
@@ -0,0 +1,282 @@
+import pMap from 'p-map';
+import { ConversationInput } from '@gitbook/api';
+import { ExposableError, Logger } from '@gitbook/runtime';
+import { FirefliesRuntimeContext, FirefliesTranscript, FirefliesGraphQLResponse } from './types';
+import { firefliesGraphQLRequest } from './client';
+
+const logger = Logger('fireflies-conversations:conversations');
+
+/**
+ * GraphQL query to fetch transcripts with sentences.
+ */
+const TRANSCRIPTS_QUERY = `
+  query Transcripts($limit: Int, $skip: Int, $fromDate: DateTime) {
+    transcripts(limit: $limit, skip: $skip, fromDate: $fromDate) {
+      id
+      title
+      date
+      duration
+      transcript_url
+      sentences {
+        index
+        speaker_name
+        speaker_id
+        text
+        start_time
+        end_time
+      }
+      speakers {
+        id
+        name
+      }
+      participants
+      host_email
+      organizer_email
+    }
+  }
+`;
+
+/**
+ * GraphQL query to fetch a single transcript by ID.
+ */
+const TRANSCRIPT_BY_ID_QUERY = `
+  query Transcript($id: String!) {
+    transcript(id: $id) {
+      id
+      title
+      date
+      duration
+      transcript_url
+      sentences {
+        index
+        speaker_name
+        speaker_id
+        text
+        start_time
+        end_time
+      }
+      speakers {
+        id
+        name
+      }
+      participants
+      host_email
+      organizer_email
+    }
+  }
+`;
+
+/**
+ * Ingest transcripts from Fireflies.
+ */
+export async function ingestConversations(context: FirefliesRuntimeContext) {
+    const { installation } = context.environment;
+    if (!installation) {
+        throw new ExposableError('Installation not found');
+    }
+
+    const limit = 50; // Fireflies API max limit is 50
+    const maxPages = 20; // Limit total pages to prevent excessive API calls
+    let skip = 0;
+    let pageIndex = 0;
+    let totalIngestedTranscripts = 0;
+
+    logger.info(
+        `Starting ingestion of transcripts from Fireflies for organization: ${installation.target.organization}`,
+    );
+
+    // Get transcripts from the last 30 days
+    const fromDate = new Date();
+    fromDate.setDate(fromDate.getDate() - 30);
+    const fromDateISO = fromDate.toISOString();
+
+    while (pageIndex < maxPages) {
+        pageIndex += 1;
+
+        try {
+            // Get transcripts from Fireflies using GraphQL
+            const response = await firefliesGraphQLRequest<
+                FirefliesGraphQLResponse<FirefliesTranscript>
+            >(context, TRANSCRIPTS_QUERY, {
+                limit,
+                skip,
+                fromDate: fromDateISO,
+            });
+
+            const transcripts = response.data?.transcripts || [];
+
+            if (transcripts.length === 0) {
+                logger.info('No more transcripts to fetch');
+                break;
+            }
+
+            logger.debug(`Fetched ${transcripts.length} transcripts`, { skip, pageIndex });
+
+            if (transcripts.length > 0) {
+                const gitbookConversations = await pMap(
+                    transcripts,
+                    async (transcript) => {
+                        return await parseTranscriptAsGitBook(context, transcript);
+                    },
+                    {
+                        concurrency: 3,
+                    },
+                );
+
+                if (gitbookConversations.length > 0) {
+                    await context.api.orgs.ingestConversation(
+                        installation.target.organization,
+                        gitbookConversations,
+                    );
+                }
+            }
+
+            totalIngestedTranscripts += transcripts.length;
+
+            // If we got fewer results than the limit, we've reached the end
+            if (transcripts.length < limit) {
+                break;
+            }
+
+            skip += limit;
+        } catch (error) {
+            logger.error('Failed to fetch transcripts from Fireflies', {
+                error: error instanceof Error ? error.message : String(error),
+                skip,
+                pageIndex,
+            });
+            // Break on error to avoid infinite loops
+            break;
+        }
+    }
+
+    logger.info(`Ingested ${totalIngestedTranscripts} transcripts from Fireflies`);
+}
+
+/**
+ * Fetch a single transcript by ID from Fireflies.
+ */
+export async function fetchTranscriptById(
+    context: FirefliesRuntimeContext,
+    transcriptId: string,
+): Promise<FirefliesTranscript | null> {
+    try {
+        const response = await firefliesGraphQLRequest<
+            FirefliesGraphQLResponse<FirefliesTranscript>
+        >(context, TRANSCRIPT_BY_ID_QUERY, {
+            id: transcriptId,
+        });
+
+        const transcript = response.data?.transcript;
+        if (!transcript) {
+            logger.info(`Transcript not found: ${transcriptId}`);
+            return null;
+        }
+
+        logger.debug(`Fetched transcript ${transcriptId}`, {
+            title: transcript.title,
+            sentenceCount: transcript.sentences?.length || 0,
+        });
+
+        return transcript;
+    } catch (error) {
+        logger.error('Failed to fetch transcript from Fireflies', {
+            transcriptId,
+            error: error instanceof Error ? error.message : String(error),
+        });
+        throw error;
+    }
+}
+
+/**
+ * Parse a Fireflies transcript into a GitBook conversation.
+ */
+export async function parseTranscriptAsGitBook(
+    context: FirefliesRuntimeContext,
+    transcript: FirefliesTranscript,
+): Promise<ConversationInput> {
+    const { installation } = context.environment;
+    if (!installation) {
+        throw new ExposableError('Installation not found');
+    }
+
+    const resultConversation: ConversationInput = {
+        id: transcript.id,
+        subject: transcript.title,
+        metadata: {
+            url: transcript.transcript_url || `https://app.fireflies.ai/viewer/${transcript.id}`,
+            attributes: {
+                transcriptId: transcript.id,
+                title: transcript.title,
+                ...(transcript.duration !== undefined && {
+                    duration: transcript.duration.toString(),
+                }),
+            },
+            createdAt: new Date(transcript.date).toISOString(),
+        },
+        parts: [],
+    };
+
+    // Convert sentences to conversation parts
+    const sentences = transcript.sentences || [];
+
+    // Create a map of speaker IDs to determine if they're team members
+    // We'll consider the host/organizer as team members, others as users
+    const teamMemberSpeakerIds = new Set<string>();
+    if (transcript.host_email) {
+        const hostSpeaker = transcript.speakers?.find(
+            (s) =>
+                s.name.toLowerCase().includes(transcript.host_email?.toLowerCase() || '') ||
+                transcript.participants?.some((p) => p === transcript.host_email),
+        );
+        if (hostSpeaker) {
+            teamMemberSpeakerIds.add(hostSpeaker.id);
+        }
+    }
+    if (transcript.organizer_email) {
+        const organizerSpeaker = transcript.speakers?.find(
+            (s) =>
+                s.name.toLowerCase().includes(transcript.organizer_email?.toLowerCase() || '') ||
+                transcript.participants?.some((p) => p === transcript.organizer_email),
+        );
+        if (organizerSpeaker) {
+            teamMemberSpeakerIds.add(organizerSpeaker.id);
+        }
+    }
+
+    // If we can't determine team members, default to treating all speakers as users
+    const hasTeamMembers = teamMemberSpeakerIds.size > 0;
+
+    for (const sentence of sentences) {
+        if (sentence.text && sentence.text.trim()) {
+            // Determine role: if we have team members identified, use that; otherwise default to user
+            const isTeamMember =
+                hasTeamMembers &&
+                sentence.speaker_id &&
+                teamMemberSpeakerIds.has(sentence.speaker_id);
+
+            const role = isTeamMember ? 'team-member' : 'user';
+
+            logger.debug('Processing sentence', {
+                transcriptId: transcript.id,
+                speakerId: sentence.speaker_id,
+                speakerName: sentence.speaker_name,
+                role,
+            });
+
+            resultConversation.parts.push({
+                type: 'message',
+                role,
+                body: sentence.text,
+            });
+        }
+    }
+
+    logger.debug('Parsed transcript as GitBook conversation', {
+        transcriptId: transcript.id,
+        sentenceCount: sentences.length,
+        partCount: resultConversation.parts.length,
+    });
+
+    return resultConversation;
+}
diff --git a/integrations/fireflies-conversations/src/index.ts b/integrations/fireflies-conversations/src/index.ts
new file mode 100644
index 000000000..f532cd6a1
--- /dev/null
+++ b/integrations/fireflies-conversations/src/index.ts
@@ -0,0 +1,51 @@
+import { createIntegration, Logger } from '@gitbook/runtime';
+import { Router } from 'itty-router';
+import { FirefliesRuntimeContext } from './types';
+import { ingestConversations } from './conversations';
+import { configComponent } from './config';
+import { handleFirefliesWebhookRequest } from './webhooks';
+
+const logger = Logger('fireflies-conversations');
+
+export default createIntegration<FirefliesRuntimeContext>({
+    fetch: async (request, context) => {
+        const router = Router({
+            base: new URL(
+                context.environment.spaceInstallation?.urls?.publicEndpoint ||
+                    context.environment.installation?.urls.publicEndpoint ||
+                    context.environment.integration.urls.publicEndpoint,
+            ).pathname,
+        });
+
+        /*
+         * Webhook handler to ingest transcripts when transcription completes.
+         */
+        router.post('/webhook', async (request) => {
+            return handleFirefliesWebhookRequest(request, context);
+        });
+
+        const response = await router.handle(request, context);
+        if (!response) {
+            return new Response(`No route matching ${request.method} ${request.url}`, {
+                status: 404,
+            });
+        }
+
+        return response;
+    },
+    components: [configComponent],
+    events: {
+        /**
+         * When the integration is installed, we fetch recent transcripts and ingest them
+         */
+        installation_setup: async (_, context) => {
+            const { installation } = context.environment;
+            if (installation?.configuration.api_key) {
+                logger.info('Starting transcript ingestion on installation setup');
+                await ingestConversations(context);
+            } else {
+                logger.info('API key not configured, skipping transcript ingestion');
+            }
+        },
+    },
+});
diff --git a/integrations/fireflies-conversations/src/types.ts b/integrations/fireflies-conversations/src/types.ts
new file mode 100644
index 000000000..03610ad69
--- /dev/null
+++ b/integrations/fireflies-conversations/src/types.ts
@@ -0,0 +1,68 @@
+import { RuntimeEnvironment, RuntimeContext } from '@gitbook/runtime';
+
+export type FirefliesInstallationConfiguration = {
+    /**
+     * Fireflies API key.
+     */
+    api_key?: string;
+    /**
+     * Fireflies webhook secret for verifying webhook signatures.
+     */
+    webhook_secret?: string;
+};
+
+export type FirefliesRuntimeEnvironment = RuntimeEnvironment<FirefliesInstallationConfiguration>;
+export type FirefliesRuntimeContext = RuntimeContext<FirefliesRuntimeEnvironment>;
+
+/**
+ * Fireflies GraphQL API types
+ */
+export interface FirefliesSentence {
+    index: number;
+    speaker_name?: string;
+    speaker_id?: string;
+    text: string;
+    raw_text?: string;
+    start_time?: number;
+    end_time?: number;
+}
+
+export interface FirefliesSpeaker {
+    id: string;
+    name: string;
+}
+
+export interface FirefliesTranscript {
+    id: string;
+    title: string;
+    date: string;
+    duration?: number;
+    sentences?: FirefliesSentence[];
+    speakers?: FirefliesSpeaker[];
+    participants?: string[];
+    host_email?: string;
+    organizer_email?: string;
+    transcript_url?: string;
+    audio_url?: string;
+    video_url?: string;
+}
+
+export interface FirefliesGraphQLResponse<T> {
+    data?: {
+        transcripts?: T[];
+        transcript?: T;
+    };
+    errors?: Array<{
+        message: string;
+        extensions?: Record<string, unknown>;
+    }>;
+}
+
+/**
+ * Fireflies webhook payload structure.
+ */
+export interface FirefliesWebhookPayload {
+    meetingId: string;
+    eventType: string;
+    clientReferenceId?: string;
+}
diff --git a/integrations/fireflies-conversations/src/webhooks.ts b/integrations/fireflies-conversations/src/webhooks.ts
new file mode 100644
index 000000000..e996a7560
--- /dev/null
+++ b/integrations/fireflies-conversations/src/webhooks.ts
@@ -0,0 +1,153 @@
+import type { IRequest } from 'itty-router';
+
+import { ExposableError, Logger } from '@gitbook/runtime';
+import { FirefliesRuntimeContext, FirefliesWebhookPayload } from './types';
+import { fetchTranscriptById } from './conversations';
+import { parseTranscriptAsGitBook } from './conversations';
+
+const logger = Logger('fireflies-conversations:webhooks');
+
+/**
+ * Constant-time string comparison to prevent timing attacks.
+ */
+function safeCompare(a: string, b: string): boolean {
+    if (a.length !== b.length) {
+        return false;
+    }
+    let result = 0;
+    for (let i = 0; i < a.length; i++) {
+        result |= a.charCodeAt(i) ^ b.charCodeAt(i);
+    }
+    return result === 0;
+}
+
+/**
+ * Verify Fireflies webhook signature using SHA-256 HMAC.
+ * The signature is in the x-hub-signature header as a hex-encoded HMAC SHA-256 hash.
+ */
+async function verifyFirefliesWebhookSignature(
+    payload: string,
+    signature: string,
+    secret: string,
+): Promise<boolean> {
+    if (!signature || !secret) {
+        return false;
+    }
+
+    try {
+        const encoder = new TextEncoder();
+        const algorithm = { name: 'HMAC', hash: 'SHA-256' };
+        const key = await crypto.subtle.importKey('raw', encoder.encode(secret), algorithm, false, [
+            'sign',
+        ]);
+
+        const signatureBuffer = await crypto.subtle.sign('HMAC', key, encoder.encode(payload));
+        const hashArray = Array.from(new Uint8Array(signatureBuffer));
+        const computedSignature = hashArray.map((b) => b.toString(16).padStart(2, '0')).join('');
+
+        return safeCompare(computedSignature, signature);
+    } catch (error) {
+        logger.error('Failed to verify webhook signature', {
+            error: error instanceof Error ? error.message : String(error),
+        });
+        return false;
+    }
+}
+
+/**
+ * Handle webhook request from Fireflies.
+ */
+export async function handleFirefliesWebhookRequest(
+    request: IRequest,
+    context: FirefliesRuntimeContext,
+) {
+    const { installation } = context.environment;
+    if (!installation) {
+        throw new ExposableError('Installation not found');
+    }
+
+    const webhookSecret = installation.configuration?.webhook_secret;
+    if (!webhookSecret) {
+        logger.warn('Webhook secret not configured, rejecting webhook request');
+        return new Response('Webhook secret not configured', { status: 401 });
+    }
+
+    // Get the raw body for signature verification
+    const rawBody = await request.text();
+    if (!rawBody) {
+        logger.warn('Empty webhook payload received');
+        return new Response('Empty payload', { status: 400 });
+    }
+
+    // Verify webhook signature
+    const signature = request.headers.get('x-hub-signature');
+    if (!signature) {
+        logger.warn('Missing x-hub-signature header');
+        return new Response('Missing signature', { status: 401 });
+    }
+
+    const isValidSignature = await verifyFirefliesWebhookSignature(
+        rawBody,
+        signature,
+        webhookSecret,
+    );
+
+    if (!isValidSignature) {
+        logger.warn('Invalid webhook signature');
+        return new Response('Invalid signature', { status: 401 });
+    }
+
+    // Parse webhook payload
+    let payload: FirefliesWebhookPayload;
+    try {
+        payload = JSON.parse(rawBody) as FirefliesWebhookPayload;
+    } catch (error) {
+        logger.error('Failed to parse webhook payload', {
+            error: error instanceof Error ? error.message : String(error),
+        });
+        return new Response('Invalid JSON payload', { status: 400 });
+    }
+
+    // Only process "Transcription completed" events
+    if (payload.eventType !== 'Transcription completed') {
+        logger.debug(`Ignoring webhook event type: ${payload.eventType}`);
+        return new Response('OK', { status: 200 });
+    }
+
+    const meetingId = payload.meetingId;
+    if (!meetingId) {
+        logger.warn('Webhook payload missing meetingId');
+        return new Response('Missing meetingId', { status: 400 });
+    }
+
+    logger.info(`Processing webhook for transcript ${meetingId}`, {
+        eventType: payload.eventType,
+        clientReferenceId: payload.clientReferenceId,
+    });
+
+    try {
+        // Fetch the transcript from Fireflies
+        const transcript = await fetchTranscriptById(context, meetingId);
+        if (!transcript) {
+            logger.warn(`Transcript not found: ${meetingId}`);
+            return new Response('Transcript not found', { status: 404 });
+        }
+
+        // Convert to GitBook conversation format
+        const gitbookConversation = await parseTranscriptAsGitBook(context, transcript);
+
+        // Ingest the conversation
+        await context.api.orgs.ingestConversation(installation.target.organization, [
+            gitbookConversation,
+        ]);
+
+        logger.info(`Successfully ingested transcript ${meetingId} from webhook`);
+        return new Response('OK', { status: 200 });
+    } catch (error) {
+        logger.error('Failed to process webhook', {
+            meetingId,
+            error: error instanceof Error ? error.message : String(error),
+        });
+        return new Response('Internal server error', { status: 500 });
+    }
+}
diff --git a/integrations/fireflies-conversations/tsconfig.json b/integrations/fireflies-conversations/tsconfig.json
new file mode 100644
index 000000000..1a48f875b
--- /dev/null
+++ b/integrations/fireflies-conversations/tsconfig.json
@@ -0,0 +1,3 @@
+{
+    "extends": "@gitbook/tsconfig/integration.json"
+}