Use Speak AI with Zoho

# 1. Create the Call record
curl -X POST "https://www.zohoapis.com/crm/v8/Calls" 
  -H "Authorization: Zoho-oauthtoken $ZOHO_OAUTH_TOKEN" 
  -H "Content-Type: application/json" 
  -d '{
    "data": [{
      "Subject": "Acme Corp - Discovery",
      "Call_Type": "Outbound",
      "Call_Start_Time": "2026-05-06T11:00:00+00:00",
      "Call_Duration": "30:20",
      "Who_Id": { "id": "4567890000000123456" },
      "Call_Purpose": "Demo",
      "Description": "Speak AI Summary: Acme is evaluating Speak for sales enablement..."
    }]
  }'

# 2. Create the Note attached to the Contact
curl -X POST "https://www.zohoapis.com/crm/v8/Contacts/4567890000000123456/Notes" 
  -H "Authorization: Zoho-oauthtoken $ZOHO_OAUTH_TOKEN" 
  -H "Content-Type: application/json" 
  -d '{
    "data": [{
      "Note_Title": "Speak AI - Acme Discovery",
      "Note_Content": "Sentiment: positive (0.78)nTopics: pricing, integrations, securitynnFull transcript: https://app.speakai.co/media/med_abc123"
    }]
  }'

# Replace zohoapis.com with .eu / .in / .com.au based on your Zoho data center.

import express from "express";
const app = express();
app.use(express.json());

const ZOHO_API = process.env.ZOHO_API_DOMAIN;   // https://www.zohoapis.com (or regional)
const ZOHO_TOKEN = process.env.ZOHO_OAUTH_TOKEN;

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

  // 1. Fetch insight + Magic Prompt summary in parallel.
  const [insightRes, summary] = await Promise.all([
    fetch(`https://api.speakai.co/v1/media/insight/${mediaId}`,
      { headers: { "x-speakai-key": process.env.SPEAK_API_KEY } }).then(r => r.json()),
    runMagicPrompt(mediaId,
      "Summarize this call in 2 sentences. End with a clear next step."),
  ]);
  const media = insightRes.data;

  // 2. Resolve Zoho Contact by attendee email (your lookup).
  const contactId = await findZohoContactByEmail(await emailFromMedia(media));
  if (!contactId) return;

  const doc = media.sentiment?.[0]?.document || {};
  const sentimentLabel = doc.Compound > 10 ? "Positive"
                       : doc.Compound < -10 ? "Negative" : "Neutral";

  // duration.inSecond -> "MM:SS" for Zoho's Call_Duration string field.
  const secs = media.duration?.inSecond || 0;
  const callDuration = `${Math.floor(secs / 60)}:${String(secs % 60).padStart(2, "0")}`;

  const headers = {
    Authorization: `Zoho-oauthtoken ${ZOHO_TOKEN}`,
    "Content-Type": "application/json",
  };

  // 3. Call record
  await fetch(`${ZOHO_API}/crm/v8/Calls`, {
    method: "POST", headers,
    body: JSON.stringify({
      data: [{
        Subject: media.name,
        Call_Type: "Outbound",
        Call_Start_Time: media.createdAt,
        Call_Duration: callDuration,
        Who_Id: { id: contactId },
        Call_Purpose: "Demo",
        Description: summary,
      }],
    }),
  });

  // 4. Note with sentiment + transcript link.
  await fetch(`${ZOHO_API}/crm/v8/Contacts/${contactId}/Notes`, {
    method: "POST", headers,
    body: JSON.stringify({
      data: [{
        Note_Title: `Speak AI - ${media.name}`,
        Note_Content:
          `Summary: ${summary}
` +
          `Sentiment: ${sentimentLabel} (Compound ${doc.Compound})

` +
          `Full transcript: https://app.speakai.co/media/${mediaId}`,
      }],
    }),
  });
});

// Helper: fire Magic Prompt + poll until completed (~2-3s typical).
async function runMagicPrompt(mediaId, prompt) {
  await fetch("https://api.speakai.co/v1/prompt/", {
    method: "POST",
    headers: {
      "x-speakai-key": process.env.SPEAK_API_KEY,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      mediaIds: [mediaId], prompt,
      isStream: false, isIndividualPrompt: true,
    }),
  });
  for (let i = 0; i < 20; i++) {
    await new Promise(r => setTimeout(r, 1000));
    const r = await fetch(
      `https://api.speakai.co/v1/prompt/messages?mediaIds=${mediaId}&pageSize=1`,
      { headers: { "x-speakai-key": process.env.SPEAK_API_KEY } }
    );
    const j = await r.json();
    const msg = j?.data?.history?.[0]?.messages?.[0];
    if (msg && msg.state === "completed") return msg.answer;
  }
  return ""; // Magic Prompt timed out -- skip the summary field.
}

app.listen(3000);

import asyncio, os
from fastapi import FastAPI, Request
import httpx

app = FastAPI()
ZOHO_API = os.environ["ZOHO_API_DOMAIN"]   # https://www.zohoapis.com or regional
ZOHO_TOKEN = os.environ["ZOHO_OAUTH_TOKEN"]

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

    headers = {"x-speakai-key": os.environ["SPEAK_API_KEY"]}
    async with httpx.AsyncClient(timeout=30) as c:
        ir = await c.get(f"https://api.speakai.co/v1/media/insight/{media_id}", headers=headers)
        media = ir.json()["data"]
    summary = await run_magic_prompt(media_id,
        "Summarize this call in 2 sentences. End with a clear next step.")

    contact_id = await find_zoho_contact_by_email(await email_from_media(media))
    if not contact_id:
        return {"ok": True}

    doc = (media.get("sentiment") or [{}])[0].get("document", {})
    compound = doc.get("Compound", 0)
    sentiment_label = "Positive" if compound > 10 else "Negative" if compound < -10 else "Neutral"

    secs = (media.get("duration") or {}).get("inSecond", 0)
    call_duration = f"{secs // 60}:{secs % 60:02d}"

    zoho_headers = {
        "Authorization": f"Zoho-oauthtoken {ZOHO_TOKEN}",
        "Content-Type": "application/json",
    }
    async with httpx.AsyncClient(timeout=30) as c:
        await c.post(f"{ZOHO_API}/crm/v8/Calls", headers=zoho_headers, json={
            "data": [{
                "Subject": media["name"],
                "Call_Type": "Outbound",
                "Call_Start_Time": media["createdAt"],
                "Call_Duration": call_duration,
                "Who_Id": {"id": contact_id},
                "Call_Purpose": "Demo",
                "Description": summary,
            }],
        })
        await c.post(f"{ZOHO_API}/crm/v8/Contacts/{contact_id}/Notes", headers=zoho_headers, json={
            "data": [{
                "Note_Title": f"Speak AI - {media['name']}",
                "Note_Content": (
                    f"Summary: {summary}
"
                    f"Sentiment: {sentiment_label} (Compound {compound})

"
                    f"Full transcript: https://app.speakai.co/media/{media_id}"
                ),
            }],
        })
    return {"ok": True}

async def run_magic_prompt(media_id: str, prompt: str) -> str:
    """Fire Magic Prompt + poll until completed (~2-3s typical)."""
    headers = {"x-speakai-key": os.environ["SPEAK_API_KEY"], "Content-Type": "application/json"}
    async with httpx.AsyncClient(timeout=30) as c:
        await c.post("https://api.speakai.co/v1/prompt/", headers=headers, json={
            "mediaIds": [media_id], "prompt": prompt,
            "isStream": False, "isIndividualPrompt": True,
        })
        for _ in range(20):
            await asyncio.sleep(1)
            r = await c.get(
                "https://api.speakai.co/v1/prompt/messages",
                params={"mediaIds": media_id, "pageSize": 1},
                headers={"x-speakai-key": os.environ["SPEAK_API_KEY"]},
            )
            history = r.json().get("data", {}).get("history", [])
            msg = history[0]["messages"][0] if history and history[0].get("messages") else None
            if msg and msg.get("state") == "completed":
                return msg.get("answer", "")
    return ""  # timed out

curl -X POST https://desk.zoho.com/api/v1/tickets 
  -H "Authorization: Zoho-oauthtoken $ZOHO_OAUTH_TOKEN" 
  -H "orgId: $ZOHO_DESK_ORG_ID" 
  -H "Content-Type: application/json" 
  -d '{
    "subject": "Support call - Acme Corp",
    "description": "Speak AI summary:nCustomer is frustrated with billing.nnSentiment: negative (-0.62)nTranscript: https://app.speakai.co/media/med_abc123",
    "contactId": "4567890000000123456",
    "departmentId": "4567890000000111222",
    "priority": "High",
    "channel": "Phone"
  }'

import asyncio, os, requests
from flask import Flask, request

app = Flask(__name__)
DESK_URL = "https://desk.zoho.com/api/v1/tickets"
ORG_ID = os.environ["ZOHO_DESK_ORG_ID"]
TOKEN = os.environ["ZOHO_OAUTH_TOKEN"]
DEPT = os.environ["ZOHO_DESK_DEPT_ID"]

def priority_from(compound: float, transcript: str) -> str:
    text = transcript.lower()
    if "cancel" in text or "refund" in text:
        return "Urgent"
    if compound < -40:
        return "High"
    if compound < 0:
        return "Medium"
    return "Low"

@app.post("/speak/webhook")
def hook():
    body = request.get_json()
    if body.get("eventType") != "media.analyzed" or body.get("state") != "processed":
        return "", 202
    media_id = body["mediaId"]

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

    doc = (media.get("sentiment") or [{}])[0].get("document", {})
    compound = doc.get("Compound", 0)
    label = "Positive" if compound > 10 else "Negative" if compound < -10 else "Neutral"
    transcript_text = " ".join(t.get("text", "") for t in (media.get("insight", {}).get("transcript") or []))

    # Run Magic Prompt for a CX-ready summary (sync via /v1/prompt/ + poll).
    summary = run_magic_prompt_sync(media_id,
        "Summarize this support call in 2 sentences. End with the customer's ask.")

    contact_id = lookup_zoho_contact(media)  # your own lookup

    payload = {
        "subject": f"Support call - {media['name']}",
        "description": (
            f"Speak AI summary:
{summary}

"
            f"Sentiment: {label} (Compound {compound})
"
            f"Transcript: https://app.speakai.co/media/{media_id}"
        ),
        "contactId": contact_id,
        "departmentId": DEPT,
        "priority": priority_from(compound, transcript_text),
        "channel": "Phone",
    }
    r = requests.post(
        DESK_URL,
        headers={
            "Authorization": f"Zoho-oauthtoken {TOKEN}",
            "orgId": ORG_ID,
            "Content-Type": "application/json",
        },
        json=payload, timeout=15,
    )
    r.raise_for_status()
    return "", 200

def run_magic_prompt_sync(media_id: str, prompt: str) -> str:
    """Fire Magic Prompt + poll until completed (~2-3s typical)."""
    import time
    headers = {"x-speakai-key": os.environ["SPEAK_API_KEY"], "Content-Type": "application/json"}
    requests.post("https://api.speakai.co/v1/prompt/", headers=headers, json={
        "mediaIds": [media_id], "prompt": prompt,
        "isStream": False, "isIndividualPrompt": True,
    }, timeout=15)
    for _ in range(20):
        time.sleep(1)
        r = requests.get(
            "https://api.speakai.co/v1/prompt/messages",
            params={"mediaIds": media_id, "pageSize": 1},
            headers={"x-speakai-key": os.environ["SPEAK_API_KEY"]}, timeout=15,
        )
        history = r.json().get("data", {}).get("history", [])
        msg = history[0]["messages"][0] if history and history[0].get("messages") else None
        if msg and msg.get("state") == "completed":
            return msg.get("answer", "")
    return ""

# Custom fields created in Setup > Modules > Deals > Layout > Add Custom Field
# Speak_Sentiment_Score__c    (Number)
# Speak_Top_Topics__c         (Multi-line text)
# Speak_Magic_Prompt_Summary__c (Multi-line text)
# Speak_Next_Step__c          (Single-line text)
# Speak_Recording_URL__c      (URL)

curl -X PUT "https://www.zohoapis.com/crm/v8/Deals/4567890000000123456" 
  -H "Authorization: Zoho-oauthtoken $ZOHO_OAUTH_TOKEN" 
  -H "Content-Type: application/json" 
  -d '{
    "data": [{
      "Speak_Sentiment_Score__c": 0.78,
      "Speak_Top_Topics__c": "Pricing; Integration; Timeline",
      "Speak_Magic_Prompt_Summary__c": "Technical buyer, evaluating vs Gong. Needs Zoho CRM auto-log.",
      "Speak_Next_Step__c": "Send pricing deck Friday",
      "Speak_Recording_URL__c": "https://app.speakai.co/media/med_abc123"
    }]
  }'

# 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"