SurveyMonkey AI: transcribe and analyze every survey response

# Auth: OAuth2 or personal access token from https://developer.surveymonkey.com/
# Scopes needed: surveys_read, responses_read, webhooks_write

curl -X POST https://api.surveymonkey.com/v3/webhooks 
  -H "Authorization: Bearer $SM_TOKEN" 
  -H "Content-Type: application/json" 
  -d '{
    "name": "speak-ingest",
    "event_type": "response_completed",
    "object_type": "survey",
    "object_ids": ["YOUR_SURVEY_ID"],
    "subscription_url": "https://your-app.example.com/sm/webhook"
  }'

# SurveyMonkey sends a thin payload on each response -- your handler must
# call back to GET /v3/surveys/{survey_id}/responses/{response_id}/details
# to fetch the full response including open-text, audio, and video answers.

import express from "express";
import fetch from "node-fetch";
import FormData from "form-data";

const app = express();
app.use(express.json());

app.post("/sm/webhook", async (req, res) => {
  res.sendStatus(200); // Respond immediately

  const { event_type, object_id: surveyId, resources } = req.body;
  if (event_type !== "response_completed") return;

  const responseId = resources?.response_id;
  if (!responseId) return;

  // 1. Fetch full response details from SurveyMonkey
  const smRes = await fetch(
    `https://api.surveymonkey.com/v3/surveys/${surveyId}/responses/${responseId}/details`,
    { headers: { Authorization: `Bearer ${process.env.SM_TOKEN}` } }
  ).then(r => r.json());

  // 2. Extract open-text answers (skip choice/rating answers)
  const openText = (smRes.pages ?? [])
    .flatMap(p => p.questions ?? [])
    .flatMap(q => q.answers ?? [])
    .map(a => a.text || "")
    .filter(Boolean)
    .join("n---n");

  if (!openText) return; // nothing to analyze

  // 3. Push to Speak AI as text media
  await fetch("https://api.speakai.co/v1/media/upload", {
    method: "POST",
    headers: {
      "x-speakai-key": process.env.SPEAK_API_KEY,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      name: `SM response ${responseId}`,
      text: openText,
      mediaType: "text",
      tags: `surveymonkey,survey-${surveyId}`,
    }),
  });
});

app.listen(3000);

import os, requests
from fastapi import FastAPI, Request

app = FastAPI()

@app.post("/sm/webhook")
async def webhook(request: Request):
    body = await request.json()
    if body.get("event_type") != "response_completed":
        return {"ok": True}

    survey_id = body.get("object_id")
    response_id = (body.get("resources") or {}).get("response_id")
    if not survey_id or not response_id:
        return {"ok": True}

    # 1. Fetch full response from SurveyMonkey
    sm_res = requests.get(
        f"https://api.surveymonkey.com/v3/surveys/{survey_id}/responses/{response_id}/details",
        headers={"Authorization": f"Bearer {os.environ['SM_TOKEN']}"},
        timeout=30,
    ).json()

    # 2. Extract open-text answers
    open_text_parts = []
    for page in sm_res.get("pages", []):
        for question in page.get("questions", []):
            for answer in question.get("answers", []):
                if answer.get("text"):
                    open_text_parts.append(answer["text"])

    if not open_text_parts:
        return {"ok": True}

    # 3. Push to Speak AI
    requests.post(
        "https://api.speakai.co/v1/media/upload",
        headers={"x-speakai-key": os.environ["SPEAK_API_KEY"]},
        json={
            "name": f"SM response {response_id}",
            "text": "n---n".join(open_text_parts),
            "mediaType": "text",
            "tags": f"surveymonkey,survey-{survey_id}",
        },
        timeout=30,
    )
    return {"ok": True}

# 1. Pull all bulk responses for a survey (paginated, max 100 per page)
curl "https://api.surveymonkey.com/v3/surveys/$SURVEY_ID/responses/bulk?per_page=100&simple=true" 
  -H "Authorization: Bearer $SM_TOKEN" 
  -H "Content-Type: application/json"

# 2. Register a Speak webhook for when analysis completes
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/analyzed",
    "events": ["media.analyzed"],
    "description": "SurveyMonkey bulk import callback"
  }'

import os, requests

SM_TOKEN = os.environ["SM_TOKEN"]
SPEAK_API_KEY = os.environ["SPEAK_API_KEY"]
SURVEY_ID = os.environ["SURVEY_ID"]

def pull_and_push(survey_id: str, since_id: str | None = None):
    """Pull SurveyMonkey bulk responses and push open-text to Speak."""
    page = 1
    processed_ids: set[str] = set()

    while True:
        params = {"per_page": 100, "simple": "true", "page": page}
        if since_id:
            params["start_created_at"] = since_id  # ISO timestamp filter

        resp = requests.get(
            f"https://api.surveymonkey.com/v3/surveys/{survey_id}/responses/bulk",
            headers={"Authorization": f"Bearer {SM_TOKEN}"},
            params=params,
            timeout=60,
        ).json()

        responses = resp.get("data", [])
        if not responses:
            break

        for r in responses:
            response_id = r["id"]
            if response_id in processed_ids:
                continue
            processed_ids.add(response_id)

            open_text_parts = []
            for page_data in r.get("pages", []):
                for question in page_data.get("questions", []):
                    for answer in question.get("answers", []):
                        if answer.get("text"):
                            open_text_parts.append(answer["text"])

            if not open_text_parts:
                continue

            requests.post(
                "https://api.speakai.co/v1/media/upload",
                headers={"x-speakai-key": SPEAK_API_KEY},
                json={
                    "name": f"SM response {response_id}",
                    "text": "n---n".join(open_text_parts),
                    "mediaType": "text",
                    "tags": f"surveymonkey,survey-{survey_id},backfill",
                },
                timeout=30,
            )

        if not resp.get("links", {}).get("next"):
            break
        page += 1


pull_and_push(SURVEY_ID)

// 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/survey-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 from Speak
  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());

  // Only process SurveyMonkey-tagged media
  if (!data.tags?.includes("surveymonkey")) return;

  const sentimentScore = data.sentiment?.[0]?.document?.Compound ?? 0;
  const sentimentLabel = sentimentScore > 10 ? "Positive" : sentimentScore < -10 ? "Negative" : "Neutral";

  // 2. Push to HubSpot as a contact note (or Salesforce Task, or Zoho Note)
  await fetch("https://api.hubapi.com/crm/v3/objects/notes", {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.HUBSPOT_TOKEN}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      properties: {
        hs_timestamp: new Date().toISOString(),
        hs_note_body: [
          `Survey response analyzed by Speak AI`,
          `Sentiment: ${sentimentLabel} (${sentimentScore.toFixed(1)})`,
          `Source: SurveyMonkey`,
          `View in Speak: https://app.speakai.co/media/${mediaId}`,
        ].join("n"),
      },
    }),
  });
});

app.listen(3000);

# Claude Desktop / Claude Code (automatikusan detektálja a telepítést)
npx @speakai/mcp-server init

# Illessze be az Speak API-kulcsot, amikor a rendszer kéri. A beállítás körülbelül 2 percet vesz igénybe.

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