Dropbox IA: trascrivi e analizza ogni file audio e video
Speak AI monitora la tua cartella Dropbox, trascrive ogni file audio e video in oltre 100 lingue e spinge i risultati strutturati nel tuo CRM, BI o di nuovo in Dropbox come file di testo. Configura un webhook Dropbox in pochi minuti o trascina un link di condivisione in Speak. Nessun download manuale, nessun re-upload.
Cosa puoi fare
Una volta che i file Dropbox fluiscono in Speak AI, ogni file audio e video diventa ricercabile, analizzabile e condivisibile. I team legali ottengono le deposizioni trascritte automaticamente. I team podcast ottengono trascritti e riassunti degli episodi. I team di ricerca trasformano le registrazioni da campo in note Notion strutturate. I team di customer success instradano le registrazioni delle chiamate per sentiment al canale giusto.
Trascrivi automaticamente ogni file Dropbox
Connetti un webhook di Dropbox al tuo handler e ogni nuovo file audio o video che si trova in una cartella viene scaricato automaticamente e inviato a Speak per la trascrizione. Oppure incolla un link di condivisione Dropbox direttamente nel caricatore di Speak. Funziona per MP3, MP4, WAV, M4A, MOV, WEBM e dozzine di altri formati.
Trascrizione etichettata per relatore in 100+ lingue
Trascrizione etichettata per il relatore in 100+ lingue. Lingua rilevata automaticamente. Elaborazione tipica: meno di 2 minuti per ora di audio. Punteggio del sentimento VADER a livello di documento e frase. Diarizzazione del relatore su tutto il file. L'output è modificabile, esportabile in DOCX/SRT/PDF/JSON ed è interrogabile attraverso l'app Speak.
Scrivi transcript e riassunti di nuovo in Dropbox
Dopo che Speak elabora un file, scarica la trascrizione o il riepilogo IA di nuovo come .txt o .md file nella stessa cartella Dropbox. Usa POST https://content.dropboxapi.com/2/files/upload dal tuo media.analyzed webhook handler. Il tuo team riceve una trascrizione insieme all'originale senza lasciare Dropbox.
Push con un clic su HubSpot, Salesforce o Zoho
Recipe webhook verificata: ricevi i dati di Speak da media.analyzed event, recupera l'insight, crea un'attività CRM. Lo stesso schema su HubSpot Meetings, Salesforce Tasks, e Zoho Calls. Source-taggato con dropbox così i report possono dividere i file da Dropbox rispetto alle chiamate live.
Configurazione in 3 passaggi
Il percorso più veloce richiede 30 secondi: incolla un link di condivisione Dropbox nel caricatore di Speak. Il percorso di automazione webhook richiede circa 5 minuti: crea un'app Dropbox, registra un callback webhook e gestisci il payload di notifica. Il percorso di scansione cartella cron non richiede affatto un handler webhook.
Iscriviti a Speak AI
Crea un account gratuito su app.speakai.co. Ottieni una prova di 7 giorni con accesso completo. Nessuna carta di credito necessaria. Una volta dentro, vai a Settings > API e copia la tua chiave API.
Scegli il tuo percorso di integrazione
Apri qualsiasi file Dropbox, fai clic su Condividi e copia il link di condivisione. Aggiungi ?dl=1 per forzare un URL di download diretto. Incolla l'URL nel campo uploader di Speak. Speak recupera il file, lo trascrivo e il risultato finisce nella tua libreria. Zero configurazione, funziona per qualsiasi file in qualsiasi cartella di Dropbox.
Crea un'app Dropbox su dropbox.com/developers/apps, scope it to the target folder (recommended: Files and folders – Single folder or Full Dropbox), and register a webhook URI in the App Console under Webhooks. When a file is added, Dropbox POSTs a thin notification to your handler: {"list_folder": {"accounts": ["dbid:..."]}, "delta": {...}}. Il tuo handler chiama quindi POST /2/files/list_folder/continue con il cursor, scarica il nuovo file tramite POST https://content.dropboxapi.com/2/files/download, and sends it to Speak's POST /v1/media/upload. Full recipe in Tab 1 below.
Per i team che non vogliono eseguire un webhook handler: configura un cron job che chiama POST /2/files/list_folder/continue usare un cursor memorizzato. Confronta l'elenco file con quello che è stato elaborato, scarica i nuovi file e carica su Speak. Più semplice da gestire; la latenza è l'intervallo cron piuttosto che quasi in tempo reale.
Hai già file Dropbox in Speak? Connetti Claude Desktop con npx @speakai/mcp-server init, o aggiungi l'URL MCP remoto a Claude.ai o ChatGPT. Cerca e sintetizza l'intera libreria proveniente da Dropbox attraverso la conversazione.
Sottoscrivi a media.analyzed
Speak invia un webhook firmato quando la trascrizione e l'analisi AI sono complete (di solito entro 60 secondi per un file di 10 minuti). Registra il tuo endpoint tramite POST /v1/webhook e agisci sui transcript man mano che arrivano: riscrivili in Dropbox, inviali al tuo CRM, o instradali per sentiment al canale Slack giusto.
Flussi di lavoro reali, risultati reali
Quattro pattern di produzione che i clienti Speak realizzano con Dropbox. Scegli quello che si adatta al tuo team e copia la ricetta.
Trascrivi automaticamente ogni file che arriva in una cartella Dropbox
Crea un'app Dropbox, registra un URI callback webhook, e lascia che Dropbox notifichi il tuo handler ogni volta che viene aggiunto un file. Il tuo handler scarica il file da Dropbox e lo invia a Speak AI. Quasi in tempo reale: solitamente elaborato entro 60-90 secondi dall'arrivo del file in Dropbox.
# 1. Go to https://www.dropbox.com/developers/apps
# 2. Click "Create app" -> "Scoped access" -> "Single folder" (recommended) or "Full Dropbox"
# 3. Name your app, e.g. "speak-transcriber"
# 4. Under "Permissions" tab: enable files.content.read (and files.content.write if writing back)
# 5. Under "Webhooks" tab: add your callback URL, e.g. https://your-app.example.com/dropbox/webhook
# 6. Dropbox sends a GET challenge first -- your handler must echo back the "challenge" query param
# 7. Store the app secret as DROPBOX_APP_SECRET and the access token as DROPBOX_TOKEN in your .env
import express from "express";
import fetch from "node-fetch";
const app = express();
app.use(express.json());
// Dropbox webhook verification challenge (GET)
app.get("/dropbox/webhook", (req, res) => {
res.send(req.query.challenge);
});
// Dropbox webhook notification (POST) - thin payload, just account IDs
app.post("/dropbox/webhook", async (req, res) => {
res.sendStatus(200); // Respond immediately
const accounts = req.body?.list_folder?.accounts ?? [];
for (const account of accounts) {
await processDropboxAccount(account);
}
});
async function processDropboxAccount(account) {
// 1. List changed files using stored cursor (or "" for first run)
const cursor = await getCursor(account); // implement storage lookup
const listRes = await fetch(
"https://api.dropboxapi.com/2/files/list_folder/continue",
{
method: "POST",
headers: {
Authorization: `Bearer ${process.env.DROPBOX_TOKEN}`,
"Content-Type": "application/json",
},
body: JSON.stringify({ cursor }),
}
).then(r => r.json());
await storeCursor(account, listRes.cursor); // store new cursor
const audioVideoExts = /.(mp3|mp4|wav|m4a|mov|webm|aac|ogg|flac)$/i;
for (const entry of listRes.entries ?? []) {
if (entry[".tag"] !== "file" || !audioVideoExts.test(entry.name)) continue;
// 2. Download file from Dropbox
const fileBuffer = await fetch(
"https://content.dropboxapi.com/2/files/download",
{
method: "POST",
headers: {
Authorization: `Bearer ${process.env.DROPBOX_TOKEN}`,
"Dropbox-API-Arg": JSON.stringify({ path: entry.path_display }),
},
}
).then(r => r.buffer());
// 3. Upload to Speak AI
const form = new FormData();
form.append("name", entry.name);
form.append("tags", "dropbox");
form.append("file", new Blob([fileBuffer]), entry.name);
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, hmac, hashlib, requests
from fastapi import FastAPI, Request, Response
app = FastAPI()
AUDIO_VIDEO_EXTS = {".mp3", ".mp4", ".wav", ".m4a", ".mov", ".webm", ".aac", ".ogg", ".flac"}
# Dropbox webhook verification challenge (GET)
@app.get("/dropbox/webhook")
async def verify(request: Request):
return Response(content=request.query_params["challenge"], media_type="text/plain")
# Dropbox webhook notification (POST)
@app.post("/dropbox/webhook")
async def webhook(request: Request):
body = await request.json()
accounts = body.get("list_folder", {}).get("accounts", [])
for account in accounts:
process_dropbox_account(account)
return {"ok": True}
def process_dropbox_account(account: str):
headers = {"Authorization": f"Bearer {os.environ['DROPBOX_TOKEN']}",
"Content-Type": "application/json"}
cursor = get_cursor(account) # implement storage lookup
list_res = requests.post(
"https://api.dropboxapi.com/2/files/list_folder/continue",
headers=headers, json={"cursor": cursor}, timeout=30
).json()
store_cursor(account, list_res["cursor"])
for entry in list_res.get("entries", []):
if entry.get(".tag") != "file":
continue
ext = os.path.splitext(entry["name"])[1].lower()
if ext not in AUDIO_VIDEO_EXTS:
continue
# Download from Dropbox
file_bytes = requests.post(
"https://content.dropboxapi.com/2/files/download",
headers={
"Authorization": f"Bearer {os.environ['DROPBOX_TOKEN']}",
"Dropbox-API-Arg": f'{{"path": "{entry["path_display"]}"}}'
},
timeout=120
).content
# Upload to Speak AI
requests.post(
"https://api.speakai.co/v1/media/upload",
headers={"x-speakai-key": os.environ["SPEAK_API_KEY"]},
files={"file": (entry["name"], file_bytes)},
data={"name": entry["name"], "tags": "dropbox"},
timeout=300,
)
Dropbox invia una sfida GET prima di attivare l'URL del tuo webhook. Il tuo handler deve rispondere con req.query.challenge (Node) or request.query_params["challenge"] (Python) e restituisci HTTP 200. Limita il token della tua app Dropbox a files.content.read solo a meno che tu non abbia anche bisogno di write-back (Tab 2).
Trasferisci la trascrizione su Dropbox come file di testo
Dopo che Speak termina l'elaborazione di un file Dropbox, scrivi la trascrizione e il riepilogo IA di nuovo su Dropbox insieme all'originale. Il tuo team ottiene .txt o .md file nella stessa cartella senza cambiare strumento.
media.analyzed webhookcurl -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/dropbox-writeback",
"events": ["media.analyzed"],
"description": "Write Speak transcript back to Dropbox"
}'
// Speak posts: { eventType, state, mediaId } (verified 2026-05-07)
import express from "express";
const app = express();
app.use(express.json());
app.post("/speak/dropbox-writeback", async (req, res) => {
const { eventType, state, mediaId } = req.body;
if (eventType !== "media.analyzed" || state !== "processed") return res.sendStatus(204);
res.sendStatus(202);
// 1. Fetch transcript from Speak
const transcript = await fetch(
`https://api.speakai.co/v1/media/${mediaId}/transcript`,
{ headers: { "x-speakai-key": process.env.SPEAK_API_KEY } }
).then(r => r.json());
// 2. Fetch insight for the summary
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 transcriptText = (transcript.data?.paragraphs ?? [])
.map(p => `[${p.speaker || "Speaker"}] ${p.text}`)
.join("nn");
const outputContent = [
`# ${media.name}`,
`Processed: ${new Date(media.updatedAt).toISOString()}`,
"",
"## Transcript",
transcriptText,
].join("n");
// 3. Write back to Dropbox - same folder as original, with -transcript.txt suffix
const originalPath = media.tags?.find(t => t.startsWith("dropbox-path:"))?.replace("dropbox-path:", "");
const outputPath = originalPath
? originalPath.replace(/(.[^.]+)$/, "-transcript.txt")
: `/transcripts/${mediaId}-transcript.txt`;
await fetch("https://content.dropboxapi.com/2/files/upload", {
method: "POST",
headers: {
Authorization: `Bearer ${process.env.DROPBOX_TOKEN}`,
"Content-Type": "application/octet-stream",
"Dropbox-API-Arg": JSON.stringify({
path: outputPath,
mode: "overwrite",
autorename: false,
}),
},
body: outputContent,
});
});
app.listen(3000);
import os, requests
from fastapi import FastAPI, Request
app = FastAPI()
@app.post("/speak/dropbox-writeback")
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"]
# 1. Fetch transcript from Speak
transcript = requests.get(
f"https://api.speakai.co/v1/media/{media_id}/transcript",
headers={"x-speakai-key": os.environ["SPEAK_API_KEY"]},
timeout=30,
).json()
# 2. Fetch insight for summary
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"]
paragraphs = transcript.get("data", {}).get("paragraphs", [])
transcript_text = "nn".join(
f"[{p.get('speaker', 'Speaker')}] {p['text']}" for p in paragraphs
)
output_content = "n".join([
f"# {insight['name']}",
f"Processed: {insight.get('updatedAt', '')}",
"",
"## Transcript",
transcript_text,
])
# 3. Write back to Dropbox
tags = insight.get("tags") or []
original_path = next((t.replace("dropbox-path:", "") for t in tags if t.startswith("dropbox-path:")), None)
if original_path:
import re
output_path = re.sub(r"(.[^.]+)$", "-transcript.txt", original_path)
else:
output_path = f"/transcripts/{media_id}-transcript.txt"
requests.post(
"https://content.dropboxapi.com/2/files/upload",
headers={
"Authorization": f"Bearer {os.environ['DROPBOX_TOKEN']}",
"Content-Type": "application/octet-stream",
"Dropbox-API-Arg": f'{{"path": "{output_path}", "mode": "overwrite", "autorename": false}}',
},
data=output_content.encode("utf-8"),
timeout=30,
)
return {"ok": True}
Etichetta ogni media proveniente da Dropbox con dropbox-path:/your/folder/file.mp3 durante il caricamento in modo che il gestore di write-back sappia dove mettere il transcript. Richiede files.content.write scope su il tuo token dell'app Dropbox.
Registra ogni chiamata da Dropbox in HubSpot, Salesforce o Zoho
Lo stesso modello middleware verificato del resto del cluster di integrazioni: ricevi il flat di Speak {eventType, state, mediaId} notifica, recupera l'insight completo tramite GET /v1/media/insight/:mediaId, quindi crea l'attività nel CRM. Etichetta la fonte con dropbox così i report possono dividere i file da Dropbox rispetto alle registrazioni di chiamate live.
// 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/dropbox-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());
// Skip files not tagged as Dropbox-sourced (optional filter)
if (!data.tags?.includes("dropbox")) return;
// 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: `Dropbox file transcript. 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);
Codice completo specifico per destinazione (HubSpot Meeting + ID associazioni, Salesforce Task + risoluzione contatti SOQL, Zoho Calls + Note) su /integrations/hubspot/, /integrations/salesforce/, e /integrations/zoho/. Il lato Speak è identico su tutti e tre i CRM di destinazione.
cerca ogni file Dropbox da Claude o ChatGPT
Connetti il server MCP di Speak a Claude o ChatGPT e il tuo team interroga l'intera libreria proveniente da Dropbox attraverso la conversazione. Nessun SQL, nessun dashboard, nessuna esportazione.
# Claude Desktop / Claude Code (rilevamento automatico dell’installazione)
npx @speakai/mcp-server init
# Incolla la tua chiave API di Speak quando richiesto. La configurazione richiede circa 2 minuti.
# Claude.ai (web) e connettore MCP di ChatGPT
# Impostazioni > Integrazioni > Aggiungi server MCP
# URL remoto: https://api.speakai.co/v1/mcp
# Intestazione di autenticazione: x-speakai-key: YOUR_SPEAK_API_KEY
# Verifica che la connessione risponda:
curl -s https://api.speakai.co/v1/mcp
-H "x-speakai-key: $SPEAK_API_KEY"
-H "Accept: application/json"
2. Promemoria di esempio che il tuo team può usare oggi:
- "Mostra ogni registrazione Dropbox dal mese scorso marcata
legaledove un relatore ha usato linguaggio negativo." - "Riassumi i 5 registrazioni di episodi podcast più lunghe importate da Dropbox questo trimestre."
- "Estrai citazioni esatte da registrazioni di chiamate clienti Dropbox dove l'argomento era prezzo o onboarding."
- "Confronta i temi chiave tra 20 registrazioni di interviste sul campo Dropbox. Raggruppa per sentiment."
- "Trova ogni file Dropbox dove un relatore ha citato un concorrente. Estrai i timestamp."
Funziona con i connettori MCP di Claude.ai, Claude Desktop, Claude Code e ChatGPT. Etichetta gli import Dropbox con dropbox per limitare le query MCP a quella fonte. Visualizza server MCP →
Perché Speak AI + Dropbox
Dropbox archivia i file. Speak trasforma quei file in dati strutturati. La combinazione gestisce l'intera pipeline dall'arrivo del file alla voce CRM, archivio di conformità o deliverable di ricerca, senza download manuali o cambio di strumento.
Acquisizione multi-source, non solo Dropbox
Dropbox è uno di dozzine di input. Lo stesso workspace Speak acquisisce registrazioni Zoom, export Google Meet, invii del registratore live, audio podcast e caricamenti di file diretti. Una libreria ricercabile, ogni fonte audio e video che il tuo team usa.
Prompt Magic personalizzati, non template fissi
Il Magic Prompt di Speak esegue i tuoi prompt su ogni file Dropbox: estrazione di reclami chiave da deposizioni legali, identificazione di highlight di podcast, scoring di obiezioni cliente, tagging di menzioni di competitor. Salva i prompt una volta, eseguili su ogni file che arriva nella cartella per sempre.
SOC 2 + GDPR + idoneo per HIPAA
Speak viene fornito con SOC 2 Type 2, conformità GDPR e piani idonei a HIPAA per clienti healthcare e legali. I dati dei tuoi file Dropbox sono crittografati in transito e a riposo, e Speak non si allena sulle tue conversazioni.
Nativo MCP per Claude e ChatGPT
L’ufficiale @speakai/mcp-server espone oltre 100 strumenti agli assistenti IA. Il tuo team interroga la libreria file Dropbox in linguaggio naturale da Claude Desktop o ChatGPT, senza esportare transcript in altri strumenti.
I team si affidano a Speak AI per le loro registrazioni più importanti
4.9 su G2
“Speak AI è stato fondamentale nel trasformare il modo in cui gestiscono i dati qualitativi. L’accuratezza della trascrizione è impressionante e gli insights NLP ci fanno risparmiare ore di analisi manuale.”
Research Director | Consulting Firm
“The ability to search across all our customer recordings and pull specific moments is a game-changer for our support team.”
Responsabile CX | Enterprise Tech
Come usare Speak AI con Dropbox per la trascrizione e l'analisi dei file
Dropbox è la piattaforma di archiviazione file utilizzata da milioni di team per memorizzare file audio e video: deposizioni legali, export di call client, episodi podcast, registrazioni di lezioni, interviste di ricerca sul campo e acquisizione batch da registratori vocali. Ognuno di questi file è una potenziale fonte di insight, decisioni e azioni di follow-up. Speak AI è ciò che trasforma quei file in dati strutturati, ricercabili e condivisibili, senza un passaggio di export manuale o un cambio di strumento.
Dove Speak si inserisce nella pipeline dei file Dropbox
Speak si esegue dopo che il file arriva in Dropbox. Dropbox gestisce l'archiviazione, la sincronizzazione, il versionamento e la condivisione. Speak gestisce la trascrizione in oltre 100 lingue, l'analisi IA con Magic Prompts personalizzati, la ricerca multi-file e l'automazione a valle. L'handoff avviene tramite un webhook Dropbox (Percorso B), una scansione di cartelle cron (Percorso C), o un incolla diretto di link di condivisione (Percorso A). Dopo l'elaborazione, Speak può scrivere la trascrizione di nuovo in Dropbox, spingere nel tuo CRM, o esporre tutto tramite MCP per Claude e ChatGPT.
Come i webhook di Dropbox funzionano con Speak
Le notifiche webhook Dropbox sono minimaliste: Dropbox invia al tuo callback URL un POST con gli ID account che sono cambiati, non il contenuto del file. Il tuo handler deve quindi chiamare POST /2/files/list_folder/continue con un cursor memorizzato per scoprire quali file sono cambiati, scarica ciascuno tramite POST https://content.dropboxapi.com/2/files/download, and upload to Speak's POST /v1/media/upload. Questo pattern di notifica a due step e fetch è standard per Dropbox. Speak non ha un OAuth diretto Dropbox: il pattern del webhook handler sopra è il percorso di produzione.
Come faccio a trascrivere automaticamente i file di Dropbox?
Tre percorsi di produzione, classificati per incremento:
- Condividi link incolla. Copia il link di condivisione di qualsiasi file Dropbox, aggiungi
?dl=1, and paste it into Speak's upload URL field. Speak fetches the file and transcribes it. Zero setup. Works for any file in any Dropbox folder. - Handler webhook Dropbox. Crea un'app Dropbox, registra un URI webhook, e lascia che Dropbox notifichi il tuo handler ogni volta che viene aggiunto un file. Il tuo handler scarica e carica su Speak AI. Quasi in tempo reale.
- Scansione cartella Cron. Sondaggio
/2/files/list_folder/continuesu un programma, confronta con i file elaborati e carica i nuovi file in Speak. Non è necessario un server webhook.
Tutti e tre forniscono lo stesso output: trascrizione completa con etichette degli speaker, riepilogo IA, sentiment, elementi d'azione, più push CRM strutturato e writeback facoltativo su Dropbox tramite files/upload API.
Speak riesce a scrivere i trascritti su Dropbox?
Sì. Dopo che Speak IA ha avviato una media.analyzed webhook, il tuo handler recupera la trascrizione da GET /v1/media/:mediaId/transcript, formats it as a .txt o .md file, e lo POSTa di nuovo su Dropbox tramite POST https://content.dropboxapi.com/2/files/upload con Dropbox-API-Arg: {"path": "/your/folder/file-transcript.txt", "mode": "overwrite"}. Il token deve files.content.write scope. Ricetta completa nel tab 2 sopra.
Casi d’uso per ruolo
Team legali usare Speak con Dropbox per trascrivere automaticamente le registrazioni di deposizioni, le esportazioni di procedimenti giudiziari e i file di interviste con i clienti che finiscono in una cartella Dropbox sicura. I Magic Prompts estraggono rivendicazioni chiave, scadenze e assegnazioni di chi parla. I piani idonei HIPAA e la conformità SOC 2 soddisfano i requisiti di dati legali.
Team podcast e contenuti trasferisci gli episodi registrati da Dropbox in Speak. Le trascrizioni vengono restituite in Dropbox accanto al file audio. Le note dello show, i marcatori di capitoli e i clip in evidenza vengono generati automaticamente tramite Magic Prompts ed esportati nel CMS o Notion del team di contenuti.
Team di ricerca clienti portare le registrazioni di interviste da campo da Dropbox nello stesso workspace delle loro sessioni Zoom e embed recorder. Codifica i temi in tutta la libreria, chiedi a Claude le citazioni verbatim tramite MCP, e costruisci deliverable di ricerca in ore invece di settimane. Vedi Speak AI per ricercatori qualitativi.
Team Sales e RevOps esportare le chiamate cliente registrate dal loro dialer o strumento di conferenza in Dropbox, quindi Speak acquisisce automaticamente, trascrive e invia ogni chiamata a HubSpot, Salesforce, o Zoho con scoring Magic Prompt su completezza della scoperta e gestione delle obiezioni. Vedi Speak AI per team di vendita.
Domande frequenti
Speak accede a tutto il mio Dropbox?
No. Quando crei un'app Dropbox per il percorso webhook, puoi limitarla a una singola cartella (consigliato) o a Dropbox completo. Se usi il percorso del link di condivisione, Speak recupera solo il file specifico che condividi: non ha accesso al tuo Dropbox più ampio. Usa l'ambito Single Folder nella tua app Dropbox per l'accesso con privilegi minimi.
Come limito Speak a una sola cartella Dropbox?
Quando crei la tua App Dropbox su dropbox.com/developers/apps, choose "Single folder" under "Choose the type of access." The app token is then scoped only to that folder. Your webhook handler only receives notifications for files in that folder. This is the recommended approach for production pipelines.
Quali tipi di file audio e video supporta Speak?
Speak processa MP3, MP4, WAV, M4A, MOV, WEBM, AAC, OGG, FLAC e la maggior parte degli altri formati audio e video comuni. Se carichi un tipo di file non supportato, Speak restituisce un errore nella richiesta di caricamento. Per un elenco completo, consulta la Documentazione API Speak AI.
Riesco a scrivere automaticamente i trascritti su Dropbox?
Sì. Registra una media.analyzed webhook in Speak, e quando un file Dropbox finisce l'elaborazione, il tuo handler recupera la trascrizione e la POST su Dropbox tramite POST https://content.dropboxapi.com/2/files/upload con il tuo token (necessita files.content.write scope). Il tab 2 sopra ha le ricette complete per Node e Python.
Come faccio a limitare l'ambito del token Dropbox?
Nella console dell'app Dropbox sotto Autorizzazioni, abilita solo ciò di cui ha bisogno la tua pipeline. Per l'ingestione di sola lettura: files.content.read. Per write-back: aggiungi anche files.content.write. Per l'elenco delle cartelle tramite webhook: aggiungi anche files.metadata.read. Evita token a livello di account, usa app token limitati alla cartella di destinazione e al set di autorizzazioni minimo.
Riesco a limitare la scansione delle cartelle solo ai file nuovi?
Sì, utilizzando i cursori. Alla prima esecuzione, la chiamata POST /2/files/list_folder per ottenere un cursor iniziale. Memorizzalo. A ogni esecuzione successiva (notifica webhook o cron), chiama POST /2/files/list_folder/continue con il cursor memorizzato. Dropbox restituisce solo il delta dal cursor precedente: solo voci nuove e modificate. Aggiorna il cursor memorizzato dopo ogni chiamata.
Inizia a usare Speak AI con Dropbox oggi
Oltre 100 strumenti. 100+ lingue. Webhook Dropbox, write-back dei trascritti, push CRM e MCP-native per Claude e ChatGPT. Lo stesso workspace delle tue sessioni Zoom, Meet, Teams e registratore live.
Prova Speak AI gratis
Crea il tuo account, incolla un link condiviso di Dropbox nell'uploader, e la trascrizione arriva automaticamente nel tuo workspace Speak AI. Accesso completo per 7 giorni. Nessuna carta di credito richiesta.
Prenota una demo
Per i team che stanno valutando Speak per una pipeline di batch processing connessa a Dropbox, prenota una demo con il team Speak. Ti mostreremo il setup del webhook, la riscrittura del transcript e il push su CRM dal vivo. Prenota una demo




