Los vídeos de YouTube contienen información valiosa bloqueada en formato de audio. Las transcripciones desbloquean este contenido para indexación de búsquedas, resúmenes, ingesta de bases de conocimientos y reutilización de contenidos. Este tutorial crea un proceso completo que toma una lista de URL de videos de YouTube, obtiene transcripciones a través de la API de Scavio, las envía a un LLM para su resumen y genera resúmenes estructurados con puntos clave y marcas de tiempo.
Requisitos previos
- Python 3.10 o superior
- solicitudes de instalación de pip openai
- Una clave API de Scavio
- Una clave API de OpenAI (o cualquier proveedor de LLM)
Guia paso a paso
Paso 1: Extraer ID de vídeo de URL
Analice las URL de YouTube para extraer las ID de los vídeos. Maneja los formatos de URL youtube.com/watch y youtu.be.
Python
from urllib.parse import urlparse, parse_qs
def extract_video_id(url: str) -> str:
parsed = urlparse(url)
if parsed.hostname in ("youtu.be",):
return parsed.path.lstrip("/")
return parse_qs(parsed.query).get("v", [url])[0]Paso 2: Obtener la transcripción de Scavio
Llame al punto final de transcripción de YouTube de Scavio con la identificación del video. La respuesta contiene segmentos de texto con marca de tiempo.
Python
def fetch_transcript(video_id: str) -> list[dict]:
r = requests.post(
"https://api.scavio.dev/api/v1/search",
headers={"x-api-key": API_KEY},
json={"platform": "youtube", "action": "transcript", "video_id": video_id}
)
r.raise_for_status()
return r.json().get("transcript", [])
def segments_to_text(segments: list[dict]) -> str:
return " ".join(seg["text"] for seg in segments)Paso 3: Resumir con un LLM
Envíe la transcripción completa a un LLM con instrucciones para producir un resumen estructurado con puntos clave.
Python
from openai import OpenAI
client = OpenAI()
def summarize(text: str, title: str = "") -> str:
response = client.chat.completions.create(
model="gpt-4o",
messages=[
{"role": "system", "content": "Summarize this YouTube transcript. Output: 1) One paragraph summary. 2) 5 key takeaways as bullet points."},
{"role": "user", "content": f"Title: {title}\n\nTranscript:\n{text[:15000]}"}
],
temperature=0
)
return response.choices[0].message.contentPaso 4: Procesar un lote de videos
Ejecute el proceso completo en varios videos y guarde los resultados en un archivo JSON.
Python
import json
def process_batch(urls: list[str]) -> list[dict]:
results = []
for url in urls:
vid = extract_video_id(url)
segments = fetch_transcript(vid)
text = segments_to_text(segments)
summary = summarize(text)
results.append({"video_id": vid, "url": url, "word_count": len(text.split()), "summary": summary})
return results
with open("summaries.json", "w") as f:
json.dump(process_batch(URLS), f, indent=2)Ejemplo en Python
Python
import os
import requests
from urllib.parse import urlparse, parse_qs
from openai import OpenAI
SCAVIO_KEY = os.environ.get("SCAVIO_API_KEY", "your_scavio_api_key")
client = OpenAI()
def get_video_id(url: str) -> str:
parsed = urlparse(url)
if parsed.hostname == "youtu.be":
return parsed.path.lstrip("/")
return parse_qs(parsed.query).get("v", [url])[0]
def get_transcript(vid: str) -> str:
r = requests.post("https://api.scavio.dev/api/v1/search",
headers={"x-api-key": SCAVIO_KEY},
json={"platform": "youtube", "action": "transcript", "video_id": vid})
r.raise_for_status()
segments = r.json().get("transcript", [])
return " ".join(s["text"] for s in segments)
def summarize(text: str) -> str:
resp = client.chat.completions.create(
model="gpt-4o", temperature=0,
messages=[{"role": "system", "content": "Summarize this transcript in 3 bullet points."},
{"role": "user", "content": text[:15000]}])
return resp.choices[0].message.content
if __name__ == "__main__":
vid = get_video_id("https://youtube.com/watch?v=dQw4w9WgXcQ")
text = get_transcript(vid)
print(f"Transcript: {len(text.split())} words")
print(summarize(text))Ejemplo en JavaScript
JavaScript
const SCAVIO_KEY = process.env.SCAVIO_API_KEY || "your_scavio_api_key";
const { OpenAI } = require("openai");
const client = new OpenAI();
function getVideoId(url) {
const u = new URL(url);
if (u.hostname === "youtu.be") return u.pathname.slice(1);
return u.searchParams.get("v") || url;
}
async function getTranscript(vid) {
const res = await fetch("https://api.scavio.dev/api/v1/search", {
method: "POST",
headers: { "x-api-key": SCAVIO_KEY, "Content-Type": "application/json" },
body: JSON.stringify({ platform: "youtube", action: "transcript", video_id: vid })
});
const data = await res.json();
return (data.transcript || []).map(s => s.text).join(" ");
}
async function main() {
const vid = getVideoId("https://youtube.com/watch?v=dQw4w9WgXcQ");
const text = await getTranscript(vid);
console.log(`Transcript: ${text.split(" ").length} words`);
const resp = await client.chat.completions.create({
model: "gpt-4o",
messages: [{ role: "user", content: `Summarize in 3 points:\n${text.slice(0, 15000)}` }]
});
console.log(resp.choices[0].message.content);
}
main().catch(console.error);Salida esperada
JSON
Transcript: 2847 words
Summary:
- The video discusses the evolution of web frameworks in 2026,
highlighting FastAPI and Next.js as the leading choices for
API-first development.
- Key takeaway: server components have fundamentally changed
how developers think about frontend architecture.
- The speaker recommends starting with FastAPI for backend
services and Next.js for full-stack applications.