RingCentral AI: transcribe meetings, calls, and recordings

# Manual: open the calendar event (Outlook, Google Calendar, etc.) that contains the RingCentral Video link.
# Click "Add attendees" and enter:
#     [email protected]
# Save the event. The bot accepts the invite and joins the RingCentral Video call automatically.

# Programmatic (Google Calendar API) - add the bot as an attendee:
curl -X PATCH "https://www.googleapis.com/calendar/v3/calendars/primary/events/$EVENT_ID" 
  -H "Authorization: Bearer $GCAL_TOKEN" 
  -H "Content-Type: application/json" 
  -d '{
    "attendees": [
      { "email": "[email protected]", "displayName": "Speak AI Notetaker" }
    ]
  }'

# In Speak AI dashboard:
# 1. Go to Meeting Assistant -> Calendar
# 2. Click "Connect Google Calendar" or "Connect Microsoft 365"
# 3. Approve the OAuth scopes when prompted
# 4. Speak scans upcoming calendar events for RingCentral Video URLs
# 5. Bot joins every RingCentral Video call that appears on your connected calendar automatically

# Note: auto-coverage works through your calendar OAuth (Google or Microsoft 365),
# not a native RingCentral OAuth. The RingCentral Video URL on the calendar event is the trigger.

curl -X POST https://api.speakai.co/v1/meeting-assistant/events/schedule 
  -H "x-speakai-key: $SPEAK_API_KEY" 
  -H "Content-Type: application/json" 
  -d '{
    "title": "Acme Corp - Demo Call",
    "meetingURL": "https://v.ringcentral.com/join/acme-team-demo",
    "meetingDate": "2026-05-15T16:00:00.000Z",
    "meetingLanguage": "en-US",
    "folderId": "507f1f77bcf86cd799439011"
  }'

// Call this when your CRM creates a RingCentral Video meeting.
async function scheduleSpeakBot({ title, rcVideoURL, scheduledAt, folderId }) {
  const r = await fetch(
    "https://api.speakai.co/v1/meeting-assistant/events/schedule",
    {
      method: "POST",
      headers: {
        "x-speakai-key": process.env.SPEAK_API_KEY,
        "Content-Type": "application/json",
      },
      body: JSON.stringify({
        title,
        meetingURL: rcVideoURL,
        meetingDate: scheduledAt,
        meetingLanguage: "en-US",
        folderId,
      }),
    }
  );
  if (!r.ok) throw new Error(`Speak schedule failed: ${r.status}`);
  const { data } = await r.json();
  // Persist data.meetingAssistantEventId for pause / resume / remove later.
  return data.meetingAssistantEventId;
}

import os, requests

def schedule_speak_bot(title: str, rc_video_url: str, scheduled_at: str, folder_id: str | None = None):
    r = requests.post(
        "https://api.speakai.co/v1/meeting-assistant/events/schedule",
        headers={
            "x-speakai-key": os.environ["SPEAK_API_KEY"],
            "Content-Type": "application/json",
        },
        json={
            "title": title,
            "meetingURL": rc_video_url,
            "meetingDate": scheduled_at,
            "meetingLanguage": "en-US",
            "folderId": folder_id,
        },
        timeout=30,
    )
    r.raise_for_status()
    return r.json()["data"]["meetingAssistantEventId"]

# Authenticate with RingCentral OAuth (developer.ringcentral.com)
# Base URL: https://platform.ringcentral.com (sandbox: https://platform.devtest.ringcentral.com)

# Register the subscription:
curl -X POST https://platform.ringcentral.com/restapi/v1.0/subscription 
  -H "Authorization: Bearer $RC_TOKEN" 
  -H "Content-Type: application/json" 
  -d '{
    "eventFilters": [
      "/restapi/v1.0/account/~/recording/~"
    ],
    "deliveryMode": {
      "transportType": "WebHook",
      "address": "https://your-app.example.com/rc/recording"
    },
    "expiresIn": 604800
  }'

# RingCentral fires a thin notification to your webhook address.
# The payload body contains a subscriptionId and event summary.
# You must call back to fetch the full recording content.

// RingCentral webhook body: { subscriptionId, event, body: { ... } }
import express from "express";
const app = express();
app.use(express.json());

app.post("/rc/recording", async (req, res) => {
  // RingCentral requires a 200 before processing
  res.sendStatus(200);

  const event = req.body.body;
  if (!event || event.eventType !== "Recording") return;

  // Recordings require the full API call to fetch content.
  // The recording ID is in event.id or event.recording.id depending on event filter used.
  const recordingId = event.id || event.recording?.id;
  if (!recordingId) return;

  // Fetch the recording content from RingCentral
  const audioResp = await fetch(
    `https://platform.ringcentral.com/restapi/v1.0/account/~/recording/${recordingId}/content`,
    { headers: { "Authorization": `Bearer ${process.env.RC_TOKEN}` } }
  );
  if (!audioResp.ok) return console.error("RC recording fetch failed:", audioResp.status);

  // Get audio as buffer and upload to Speak
  const audioBuffer = Buffer.from(await audioResp.arrayBuffer());
  const form = new FormData();
  form.append("name", `RingEX call ${recordingId}`);
  form.append("mediaType", "audio");
  form.append("sourceLanguage", "en-US");
  form.append("tags", "ringcentral,ringex,phone");
  form.append("file", new Blob([audioBuffer], { type: "audio/mpeg" }), `rc-${recordingId}.mp3`);

  await fetch("https://api.speakai.co/v1/media/upload", {
    method: "POST",
    headers: { "x-speakai-key": process.env.SPEAK_API_KEY },
    body: form,
  });
});

app.listen(3000);

import os, io, requests
from fastapi import FastAPI, Request

app = FastAPI()

@app.post("/rc/recording")
async def hook(req: Request):
    body = await req.json()
    event = body.get("body", {})
    if event.get("eventType") != "Recording":
        return {"ok": True}

    recording_id = event.get("id") or (event.get("recording") or {}).get("id")
    if not recording_id:
        return {"ok": True}

    # Fetch audio content from RingCentral
    rc_resp = requests.get(
        f"https://platform.ringcentral.com/restapi/v1.0/account/~/recording/{recording_id}/content",
        headers={"Authorization": f"Bearer {os.environ['RC_TOKEN']}"},
        timeout=60,
    )
    rc_resp.raise_for_status()

    # Upload to Speak
    requests.post(
        "https://api.speakai.co/v1/media/upload",
        headers={"x-speakai-key": os.environ["SPEAK_API_KEY"]},
        files={"file": (f"rc-{recording_id}.mp3", io.BytesIO(rc_resp.content), "audio/mpeg")},
        data={
            "name": f"RingEX call {recording_id}",
            "mediaType": "audio",
            "sourceLanguage": "en-US",
            "tags": "ringcentral,ringex,phone",
        },
        timeout=120,
    )
    return {"ok": True}

# Pull call log entries to enrich Speak metadata with caller, duration, direction, extension.
curl "https://platform.ringcentral.com/restapi/v1.0/account/~/call-log?type=Voice&view=Detailed&dateFrom=2026-05-07T00:00:00Z" 
  -H "Authorization: Bearer $RC_TOKEN"

# Key fields in response:
# .records[].id           - call ID
# .records[].duration     - seconds
# .records[].direction    - Inbound / Outbound
# .records[].from.name    - caller name
# .records[].recording.id - recording ID (same ID used in content endpoint)

// Speak webhook body shape (verified 2026-05-07): { eventType, state, mediaId }
import express from "express";
const app = express();
app.use(express.json());

app.post("/speak/rc-to-crm", 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
  const { data } = await fetch(
    `https://api.speakai.co/v1/media/insight/${mediaId}`,
    { headers: { "x-speakai-key": process.env.SPEAK_API_KEY } }
  ).then(r => r.json());

  // 2. Push to HubSpot Meetings (or Salesforce Tasks, or Zoho Calls)
  const start = new Date(data.createdAt);
  const end = new Date(start.getTime() + (data.duration?.inSecond || 0) * 1000);

  await fetch("https://api.hubapi.com/crm/v3/objects/meetings", {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.HUBSPOT_TOKEN}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      properties: {
        hs_timestamp: start.toISOString(),
        hs_meeting_title: data.name,
        hs_meeting_body: `RingCentral call summary. Open in Speak: https://app.speakai.co/media/${mediaId}`,
        hs_meeting_external_url: `https://app.speakai.co/media/${mediaId}`,
        hs_meeting_start_time: start.toISOString(),
        hs_meeting_end_time: end.toISOString(),
        hs_meeting_outcome: "COMPLETED",
      },
    }),
  });
});

app.listen(3000);

# Claude Desktop / Claude Code (detecta automáticamente tu instalación)
npx @speakai/mcp-server init

# Pega tu clave API de Speak cuando se te pida. La configuración toma aproximadamente 2 minutos.

# Claude.ai (web) y conector MCP de ChatGPT
# 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"