Integration

Use Speak AI with Slack

Name: Speak AI for Slack
Brand: Speak AI
Availability: InStock

Push transcripts, summaries, and AI insights from Speak into any Slack channel. Connect Slack to Speak in two clicks via OAuth, or wire up a custom Incoming Webhook flow for full control. Native bidirectional integration. Production-ready in under 10 minutes.

Try Speak Free
View API Docs

Free 7-day trial. No credit card required. Native Slack OAuth or Incoming Webhook flows.

OAuthNative Connect

Block KitRich Cards

100+Languages

Freeto Try

Trusted by 250,000+ people and teams

What you can do

Once Speak is connected to Slack, every transcribed call, interview, or recording can land in the channel where work happens. Sales teams get deal-call summaries in their pipeline channel. Support teams get sentiment alerts in their on-call channel. Research teams get verbatim quotes pushed to their synthesis channel.

Push transcripts to any Slack channel

One-click OAuth connects your Slack workspace to Speak. Pick a channel, send the full transcript or just the AI summary. Use Speak’s POST /v1/integration/slack/send-transcription endpoint to fire transcripts programmatically from your CRM or scheduler.

Auto-notify on every `media.analyzed`

Subscribe a Slack Incoming Webhook to Speak’s media.analyzed event. Every time a recording finishes processing, Speak posts a Block Kit card to your chosen Slack channel with the summary, sentiment, and a link back to the full Speak record.

Run Magic Prompts against transcripts from a slash command

Let your team query Speak from Slack. Build a custom slash command (/speak or /ask-speak) that pipes through your server, calls Speak’s Magic Prompt API, and replies back into the Slack thread with the answer.

Search every call from Claude, ChatGPT, and Slack

Speak’s official MCP server exposes 83 tools to AI assistants. Pair it with Slack’s AI Assistant API or a custom bot to let your team ask questions about the entire Speak library directly in Slack threads.

Set up in 3 steps

Two production paths. Native OAuth for the in-app experience (recommended). Incoming Webhook for full control over message formatting and routing logic.

Sign up for Speak AI

Create a free account at app.speakai.co. You get a 7-day trial with full access. No credit card needed. Once you are in, go to Settings > API and copy your API key.

Pick your integration path

Native Slack OAuth (recommended)

In Speak, go to Settings > Integrations > Slack and click Connect Slack. Approve the OAuth scopes for the workspace and channels you want to use. Speak then exposes a channel picker, the send-transcription endpoint, and a Slack Events API subscription. No code required.

Incoming Webhook (custom flow)

Create a Slack app at api.slack.com/apps, enable Incoming Webhooks, and copy the webhook URL. Subscribe Speak’s media.analyzed webhook (POST /v1/webhook) to your handler, then forward formatted Block Kit messages to the Slack webhook URL. Best when you need custom routing or formatting.

Slash command (server-side)

Add a slash command in your Slack app pointing to /slack/command on your server. Your handler reads text and channel_id, fires Speak’s Magic Prompt API, polls for the answer, and posts back to Slack via response_url. Useful for ad-hoc team queries.

MCP for Claude and ChatGPT in Slack

Already have calls in Speak? Connect Claude Desktop with npx @speakai/mcp-server init, or add the MCP URL to your Slack AI Assistant. Your team queries the Speak library through conversation in any thread.

Subscribe to `media.analyzed`

Speak fires a signed webhook when transcription and AI analysis complete (usually within 60 seconds for a 10-minute call). Register your endpoint via POST /v1/webhook, format the payload as a Slack Block Kit card, and post it to your channel. Real-time team awareness, zero polling.

Try Speak Free
View API Docs

Real workflows, real results

Four production patterns Speak customers ship with Slack. Pick the one that fits your team and copy the recipe.

1Native OAuth
2Incoming Webhook
3Slash command
4MCP via Claude

For most teams · Slack OAuth + Speak’s send-transcription endpoint

Connect Slack via OAuth and send transcripts from your code

Use Speak’s native Slack integration. Connect Slack via OAuth in the Speak dashboard once, then call Speak’s send-transcription endpoint with the mediaId, channelId, and accountId from your CRM, automation, or a webhook handler. No Block Kit construction, no Slack signing required, full markdown rendering of the transcript.

1. Connect Slack in Speak (one-time)

# In Speak AI dashboard:
# 1. Go to Settings -> Integrations -> Slack
# 2. Click "Connect Slack"
# 3. Choose your Slack workspace + channels you want to enable
# 4. Approve scopes (chat:write, channels:read, users:read, files:write)
# 5. Speak stores an accountId you reference from the API

# Or hit Speak's connect endpoint programmatically:
curl -X POST https://api.speakai.co/v1/integration/slack/connect \
  -H "x-speakai-key: $SPEAK_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"code": "$SLACK_OAUTH_CODE", "redirectUri": "https://yourapp/slack-redirect"}'

2. List the workspace’s available channels

curl https://api.speakai.co/v1/integration/slack/$ACCOUNT_ID/channels \
  -H "x-speakai-key: $SPEAK_API_KEY"

# Response:
# {
#   "status": "success",
#   "data": {
#     "channels": [
#       { "id": "C0123ABCD", "name": "deals-pipeline" },
#       { "id": "C0123EFGH", "name": "support-oncall" },
#       ...
#     ]
#   }
# }

3. Push a transcript to a Slack channel

curl
Node
Python

curl -X POST https://api.speakai.co/v1/integration/slack/send-transcription \
  -H "x-speakai-key: $SPEAK_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "mediaId": "14c8dd9c0a89",
    "channelId": "C0123ABCD",
    "channelName": "deals-pipeline",
    "accountId": "$SLACK_ACCOUNT_ID"
  }'

# Speak posts the formatted transcript card to the channel.
# AI summary, speaker labels, sentiment chip, link back to the Speak record.

// Trigger this from your CRM, scheduler, or a Speak webhook handler.
async function pushTranscriptToSlack({ mediaId, channelId, channelName, accountId }) {
  const r = await fetch(
    "https://api.speakai.co/v1/integration/slack/send-transcription",
    {
      method: "POST",
      headers: {
        "x-speakai-key": process.env.SPEAK_API_KEY,
        "Content-Type": "application/json",
      },
      body: JSON.stringify({ mediaId, channelId, channelName, accountId }),
    }
  );
  if (!r.ok) throw new Error(`Slack push failed: ${r.status}`);
  return r.json();
}

import os, requests

def push_transcript_to_slack(media_id: str, channel_id: str, channel_name: str, account_id: str):
    r = requests.post(
        "https://api.speakai.co/v1/integration/slack/send-transcription",
        headers={
            "x-speakai-key": os.environ["SPEAK_API_KEY"],
            "Content-Type": "application/json",
        },
        json={
            "mediaId": media_id,
            "channelId": channel_id,
            "channelName": channel_name,
            "accountId": account_id,
        },
        timeout=30,
    )
    r.raise_for_status()
    return r.json()

Speak handles the Slack auth, signing, retry, and Block Kit formatting on its side. You only pass the four IDs.

For custom routing logic · Slack Incoming Webhook

Auto-post AI summaries to Slack when a recording finishes

For full control over message formatting and routing logic, subscribe Speak’s media.analyzed webhook to your own handler. Fetch the insight from Speak, format it as a Slack Block Kit card, and POST to a Slack Incoming Webhook URL. Useful when different folder tags should route to different channels, or when you want to surface only certain sentiment thresholds.

1. Create a Slack app + Incoming Webhook

# 1. Go to https://api.slack.com/apps
# 2. Click "Create New App" -> "From scratch"
# 3. Name it (e.g. "Speak AI Bot") and choose your workspace
# 4. Under Features, enable "Incoming Webhooks"
# 5. Click "Add New Webhook to Workspace"
# 6. Pick the channel that will receive Speak summaries
# 7. Copy the Webhook URL (https://hooks.slack.com/services/T.../B.../xxx)

# Store the URL as an env var: SLACK_WEBHOOK_URL
# Same URL is reusable for every recording analyzed by Speak.

2. Register Speak’s media.analyzed webhook

curl -X POST https://api.speakai.co/v1/webhook \
  -H "x-speakai-key: $SPEAK_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "callbackUrl": "https://your-app.example.com/speak/slack-webhook",
    "events": ["media.analyzed"],
    "description": "Forward Speak insights to Slack"
  }'

3. Forward formatted Block Kit cards to Slack

Node
Python

// Speak posts a thin notification: { eventType, state, mediaId } (verified 2026-05-07).
import express from "express";
const app = express();
app.use(express.json());

app.post("/speak/slack-webhook", async (req, res) => {
  const { eventType, state, mediaId } = req.body;
  if (eventType !== "media.analyzed" || state !== "processed") return res.sendStatus(204);
  res.sendStatus(202);

  // 1. Fetch full insight from Speak
  const insight = await fetch(
    `https://api.speakai.co/v1/media/insight/${mediaId}`,
    { headers: { "x-speakai-key": process.env.SPEAK_API_KEY } }
  ).then(r => r.json());

  const media = insight.data;
  const compound = media.sentiment?.[0]?.document?.Compound ?? 0;
  const sentiment = compound > 10 ? ":green_circle: Positive"
                  : compound < -10 ? ":red_circle: Negative" : ":white_circle: Neutral";

  // 2. Build a Slack Block Kit card
  const blocks = [
    {
      type: "header",
      text: { type: "plain_text", text: media.name },
    },
    {
      type: "section",
      fields: [
        { type: "mrkdwn", text: `*Sentiment*\n${sentiment} (${compound})` },
        { type: "mrkdwn", text: `*Duration*\n${Math.round(media.duration?.inSecond / 60)} min` },
      ],
    },
    {
      type: "actions",
      elements: [{
        type: "button",
        text: { type: "plain_text", text: "Open in Speak" },
        url: `https://app.speakai.co/media/${mediaId}`,
      }],
    },
  ];

  // 3. POST to Slack Incoming Webhook
  await fetch(process.env.SLACK_WEBHOOK_URL, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ blocks }),
  });
});

app.listen(3000);

import os, requests
from fastapi import FastAPI, Request

app = FastAPI()

@app.post("/speak/slack-webhook")
async def hook(req: Request):
    body = await req.json()
    if body.get("eventType") != "media.analyzed" or body.get("state") != "processed":
        return {"ok": True}
    media_id = body["mediaId"]

    insight = requests.get(
        f"https://api.speakai.co/v1/media/insight/{media_id}",
        headers={"x-speakai-key": os.environ["SPEAK_API_KEY"]},
        timeout=30,
    ).json()["data"]

    compound = (insight.get("sentiment") or [{}])[0].get("document", {}).get("Compound", 0)
    sentiment_emoji = ":green_circle: Positive" if compound > 10 else ":red_circle: Negative" if compound < -10 else ":white_circle: Neutral"

    blocks = [
        {"type": "header", "text": {"type": "plain_text", "text": insight["name"]}},
        {"type": "section", "fields": [
            {"type": "mrkdwn", "text": f"*Sentiment*\n{sentiment_emoji} ({compound})"},
            {"type": "mrkdwn", "text": f"*Duration*\n{round(insight.get('duration', {}).get('inSecond', 0) / 60)} min"},
        ]},
        {"type": "actions", "elements": [{
            "type": "button",
            "text": {"type": "plain_text", "text": "Open in Speak"},
            "url": f"https://app.speakai.co/media/{media_id}",
        }]},
    ]

    requests.post(
        os.environ["SLACK_WEBHOOK_URL"],
        json={"blocks": blocks},
        timeout=15,
    )
    return {"ok": True}

Branch by folder ID, tag, or sentiment threshold to route different recording types into different Slack channels. Slack Incoming Webhooks accept up to 50 blocks per message.

For ad-hoc team queries · Slash command + Magic Prompt API

Let your team query Speak from Slack

Add a slash command (/speak or /ask-speak) that fires Speak’s Magic Prompt API and posts the answer back into the Slack thread. Useful for asking ad-hoc questions about a specific call without leaving Slack: “What was the customer’s main objection in the call from yesterday?”

1. Add the slash command in your Slack app

# In your Slack app at https://api.slack.com/apps:
# 1. Features -> Slash Commands -> Create New Command
# 2. Command:        /ask-speak
# 3. Request URL:    https://your-app.example.com/slack/ask-speak
# 4. Short description: Ask a question about a Speak recording
# 5. Usage hint:     [mediaId] [your question]
# 6. Reinstall the app to your workspace

# Slack POSTs to your URL with form-encoded body:
#   token, team_id, channel_id, user_id, command, text, response_url
#
# Verify the request with the X-Slack-Signature header
# (HMAC-SHA256 with your Slack signing secret).

2. Handler: parse, fire Magic Prompt, reply async

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

const app = express();
app.use(express.urlencoded({ extended: false }));

function verifySlack(req) {
  const ts = req.headers["x-slack-request-timestamp"];
  const sig = req.headers["x-slack-signature"];
  const base = `v0:${ts}:${req.rawBody}`;
  const hmac = "v0=" + crypto
    .createHmac("sha256", process.env.SLACK_SIGNING_SECRET)
    .update(base).digest("hex");
  return crypto.timingSafeEqual(Buffer.from(hmac), Buffer.from(sig));
}

app.post("/slack/ask-speak", async (req, res) => {
  if (!verifySlack(req)) return res.sendStatus(401);
  res.json({ response_type: "in_channel", text: "Asking Speak..." }); // ack within 3s

  const [mediaId, ...rest] = (req.body.text || "").split(" ");
  const prompt = rest.join(" ");
  const responseUrl = req.body.response_url;

  // Fire Magic Prompt + poll until completed (typical 2-3s)
  const headers = { "x-speakai-key": process.env.SPEAK_API_KEY };
  await fetch("https://api.speakai.co/v1/prompt/", {
    method: "POST",
    headers: { ...headers, "Content-Type": "application/json" },
    body: JSON.stringify({
      mediaIds: [mediaId], prompt,
      isStream: false, isIndividualPrompt: true,
    }),
  });

  let answer = "(timed out)";
  for (let i = 0; i < 20; i++) {
    await new Promise(r => setTimeout(r, 1000));
    const r2 = await fetch(
      `https://api.speakai.co/v1/prompt/messages?mediaIds=${mediaId}&pageSize=1`,
      { headers }
    );
    const j = await r2.json();
    const msg = j?.data?.history?.[0]?.messages?.[0];
    if (msg?.state === "completed") { answer = msg.answer; break; }
  }

  // Post answer back to the same Slack thread
  await fetch(responseUrl, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ response_type: "in_channel", text: answer }),
  });
});

app.listen(3000);

Acknowledge within 3 seconds (Slack timeout) and post the real answer asynchronously to response_url. Magic Prompt typically completes in 2 to 3 seconds for a 50,000-character transcript.

For analysts and team leads · Natural language

Search every recording from Claude or ChatGPT, then drop answers into Slack

Connect Speak’s MCP server to Claude or ChatGPT. Run a query, copy the structured answer into a Slack thread. Or wire Claude into Slack with the Anthropic Slack app and let your team ask questions in any channel.

1. Install the MCP server

CLI
Remote URL

# Claude Desktop / Claude Code (auto-detects your installation)
npx @speakai/mcp-server init

# Paste your Speak API key when prompted. Setup takes about 2 minutes.

# Claude.ai (web) and ChatGPT MCP connector
# Settings > Integrations > Add MCP Server
# Remote URL:    https://api.speakai.co/v1/mcp
# Auth header:   x-speakai-key: YOUR_SPEAK_API_KEY

# Verify the connection responds:
curl -s https://api.speakai.co/v1/mcp \
  -H "x-speakai-key: $SPEAK_API_KEY" \
  -H "Accept: application/json"

2. Example prompts your team can use today:

“Pull the 3 most recent customer calls where pricing was raised as an objection. Format as a Slack-ready summary.”
“Summarize this week’s support calls by sentiment. Output as a bulleted list I can drop into our oncall Slack channel.”
“Find the discovery call from last Friday with Acme Corp. Pull the action items and format as Slack mrkdwn.”
“Compare the 5 longest sales calls this month for discovery completeness. Score each on a 0-10 rubric.”
“Pull verbatim quotes from research interviews tagged onboarding where users mentioned friction. Drop the top 5 in a thread.”

Works with Claude.ai, Claude Desktop, Claude Code, and ChatGPT MCP connectors. View MCP server →

Why Speak AI + Slack

Slack is where your team works. Speak is where your conversations are analyzed. The combination is how a 5-person sales team and a 5,000-person enterprise both turn every call into immediate team awareness without a Notion or BI hop.

Native OAuth, not just webhooks

Most “Slack integrations” are actually outbound-only Incoming Webhooks. Speak ships full Slack OAuth, channel listing, signed Events API ingestion, and per-account event subscriptions. Two-way connection, not one-way notifications.

Custom Magic Prompts, not fixed reports

Send any structured analysis to any Slack channel. Sentiment thresholds, custom rubrics, MEDDIC scores, competitor mention extraction. Save the prompt once, run it on every recording forever, route the result to the channel where work happens.

MCP-native for Claude and ChatGPT

The official @speakai/mcp-server exposes 83 tools to AI assistants. Pair it with Claude in Slack or ChatGPT to let your team query the entire Speak library through conversation in any channel.

One workspace, every conversation

Speak ingests Zoom, Teams, Meet, Webex, Twilio, Loom, Drive, Dropbox, podcast audio, embedded recorder submissions, and direct uploads. Slack is the front door for the analysis layer of every one of them.

Teams trust Speak AI for their most important calls

★★★★★
4.9 on G2

“Speak AI has been instrumental in transforming how we handle qualitative data. The transcription accuracy is impressive, and the NLP insights save us hours of manual analysis.”

Research Director | Consulting Firm

“We switched from Otter.ai and the depth of analysis is on another level. Sentiment scoring, keyword extraction, and theme detection all happen automatically.”

Product Manager | SaaS Company

“The ability to search across all our customer calls and pull specific moments is a game-changer for our support team.”

Head of CX | Enterprise Tech

How to use Speak AI with Slack for transcription and team awareness

Slack is the operating system for most modern teams. Sales pipelines run in deal channels. Support queues run in oncall channels. Research synthesis happens in dedicated insight channels. The challenge is getting structured intelligence about customer conversations into those channels in real time, without forcing your team to leave Slack to read transcripts. Speak AI solves this by treating Slack as a first-class output destination, not an afterthought.

Where Speak fits in the Slack workflow

Speak runs after the call. Recordings flow in from Zoom, Teams, Meet, Webex, Twilio, Loom, Drive, Dropbox, podcast audio, embedded recorder submissions, or direct uploads. Speak transcribes them in 100+ languages, runs AI analysis, and exposes the result through three Slack-facing surfaces: a native OAuth integration with a channel picker, an Incoming Webhook flow for custom routing logic, and a slash-command path for ad-hoc team queries.

Native Slack integration vs Incoming Webhook

The native Slack OAuth path (POST /v1/integration/slack/connect) is the recommended starting point. It exposes a channel picker inside Speak, handles signing, retries, and Block Kit formatting on Speak’s side, and supports two-way events (Slack to Speak via the Events API). Best for teams that want a working integration in 5 minutes with no Block Kit code to maintain.

The Incoming Webhook path is for teams that need custom routing logic. Different folder tags route to different channels. Different sentiment thresholds trigger different message templates. Different custom Magic Prompts produce different Block Kit cards. You write the formatting code; Speak supplies the analysis. Best when the routing logic is non-trivial.

Slash command pattern

The slash command path (Tab 3 above) is ad-hoc, not real-time. A team member types /ask-speak {mediaId} {question} in any Slack channel. Your handler verifies the Slack signature, fires Speak’s Magic Prompt API, polls for the answer (typical completion 2 to 3 seconds), and posts back to the same thread via response_url. Best for one-off questions about specific calls without context-switching to the Speak app.

Authentication and Slack scopes

The native OAuth flow requests these Slack scopes: chat:write (post messages), channels:read (list public channels), users:read (resolve user mentions), files:write (attach transcript files). The Events API path adds commands for slash command handling. Your Speak account stores the Slack accountId reference; the actual OAuth token lives encrypted on Speak’s side.

Real-time vs post-call delivery

Speak posts to Slack after the call ends, with first transcripts typically available within 60 seconds for a 10-minute call. For during-call live captions, use Slack’s native huddle transcription or pair Slack with a real-time transcription provider. Use Speak for the post-call analysis layer that lands in your team channels.

How do I forward Speak transcripts into Slack automatically?

Three production paths, ranked by lift:

Native OAuth + send-transcription endpoint. Connect Slack in Speak, then call POST /v1/integration/slack/send-transcription with mediaId, channelId, and accountId. Speak handles formatting and posting. Best for most teams.
Incoming Webhook + Block Kit. Subscribe Speak’s media.analyzed webhook, fetch the insight, format as Block Kit, POST to your Slack webhook URL. Best for custom routing.
Zapier. Trigger: Speak New Media Analyzed. Action: Slack Send Channel Message. 5-minute setup. Best for SMB teams without engineering bandwidth.

The same patterns work for sales calls, support calls, customer interviews, and recorded internal meetings.

Use cases by role

Sales and RevOps teams push deal-call summaries to a pipeline channel. Magic Prompts score discovery completeness, surface objections, and extract competitor mentions. The whole team sees every call without watching the recording. See Speak AI for sales teams.

Customer support and CX teams route inbound call analysis to oncall channels. Sentiment dips trigger automatic alerts. Cancellation language fires a manager mention. Multilingual support queues work without per-language setup since Speak supports 100+ languages.

Customer research teams push verbatim quotes from interviews into research synthesis channels. Code themes across the entire library, ask Claude for verbatim quotes via MCP, drop the top hits into a thread. See Speak AI for qualitative researchers.

Training and enablement teams turn coaching moments into Slack-accessible content. Speak’s analysis surfaces missed discovery questions and scripted-line drift; the structured output lands in the training channel for review. See Speak AI for training and development.

Frequently asked questions

Does Speak AI have a native Slack integration?

Yes. Speak ships full Slack OAuth, channel listing, signed Events API ingestion, and per-account event subscriptions. Connect once at Settings > Integrations > Slack in the Speak dashboard. Most teams use this rather than building custom Incoming Webhooks.

How do I post a Speak transcript to a Slack channel?

Two ways. Native: connect Slack in Speak, then call POST /v1/integration/slack/send-transcription with the media ID, channel ID, and Speak account ID. Speak handles formatting and posting. Custom: subscribe Speak’s media.analyzed webhook, fetch the insight, build a Block Kit card, POST to a Slack Incoming Webhook URL. Both paths run in production today.

Can I add a slash command to query Speak from Slack?

Yes. Add a slash command in your Slack app pointing to your server. Your handler verifies the Slack signature, fires Speak’s Magic Prompt API, polls for the answer, and posts back to the same thread via response_url. Acknowledge within 3 seconds (Slack timeout) and post the real answer asynchronously.

What Slack scopes does the native integration request?

The OAuth flow requests chat:write, channels:read, users:read, and files:write for the message-posting flow. Add commands if you wire up the slash-command Events API path. Your Slack workspace admin can pre-approve Speak in the admin console for org-wide rollouts.

Can Speak post to private channels?

Yes, but the Speak app must be invited to the private channel first. Public channels appear in the channel picker automatically once Slack OAuth is approved. For private channels, run /invite @speakai in the channel before listing it via GET /v1/integration/slack/:accountId/channels.

Can I try Speak AI for free with my Slack workspace?

Yes. The 7-day trial includes 30 minutes of transcription, full API access, the native Slack OAuth, the send-transcription endpoint, and the MCP server. No credit card required. Connect a Slack workspace, send a test recording, and validate the full pipeline before committing.

Start using Speak AI with Slack today

83 analysis tools. 100+ languages. Native Slack OAuth, Incoming Webhook, slash commands. MCP-native for Claude and ChatGPT. Same workspace as your Zoom, Teams, Webex, and Twilio calls.

Try Speak AI free

Create your account, connect Slack, and the next recording lands in your channel automatically. Full access for 7 days. No credit card required.

Try Speak Free
Login

View the API docs

Full reference for the send-transcription endpoint, webhook event types, the Magic Prompt API, and the Speak Slack Events API path. Plus the Speak Zapier app and the official MCP server on NPM.

API Docs
Zapier App
MCP on NPM

All Integrations
Google Meet
Zoom Integration
Twilio Integration
Developers

Use Speak AI with Slack

Use Speak AI with Slack

What you can do

Push transcripts to any Slack channel

Auto-notify on every media.analyzed

Run Magic Prompts against transcripts from a slash command

Search every call from Claude, ChatGPT, and Slack

Set up in 3 steps

Sign up for Speak AI

Pick your integration path

Subscribe to media.analyzed

Real workflows, real results

Connect Slack via OAuth and send transcripts from your code

Auto-post AI summaries to Slack when a recording finishes

Let your team query Speak from Slack

Search every recording from Claude or ChatGPT, then drop answers into Slack

Why Speak AI + Slack

Native OAuth, not just webhooks

Custom Magic Prompts, not fixed reports

MCP-native for Claude and ChatGPT

One workspace, every conversation

Teams trust Speak AI for their most important calls

How to use Speak AI with Slack for transcription and team awareness

Where Speak fits in the Slack workflow

Native Slack integration vs Incoming Webhook

Slash command pattern

Authentication and Slack scopes

Real-time vs post-call delivery

How do I forward Speak transcripts into Slack automatically?

Use cases by role

Frequently asked questions

Start using Speak AI with Slack today

Try Speak AI free

View the API docs

Auto-notify on every `media.analyzed`

Subscribe to `media.analyzed`