Les vidéos YouTube contiennent des informations précieuses enfermées dans un format audio. Les transcriptions débloquent ce contenu pour l'indexation de recherche, la synthèse, l'ingestion dans une base de connaissances et le réemploi du contenu. Ce tutoriel construit un pipeline complet qui prend une liste d'URLs de vidéos YouTube, récupère les transcriptions via l'API Scavio, les envoie à un LLM pour synthèse, et produit des résumés structurés avec points clés et horodatages.
Prérequis
- Python 3.10 ou supérieur
- pip install requests openai
- Une clé API Scavio
- Une clé API OpenAI (ou tout fournisseur LLM)
Parcours
Étape 1: Extraire les identifiants vidéo des URLs
Analyser les URLs YouTube pour extraire les identifiants vidéo. Gérer les formats d'URL youtube.com/watch et 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]Étape 2: Récupérer la transcription de Scavio
Appeler le point de terminaison de transcription YouTube de Scavio avec l'identifiant vidéo. La réponse contient des segments de texte horodatés.
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)Étape 3: Résumer avec un LLM
Envoyer la transcription complète à un LLM avec des instructions pour produire un résumé structuré avec les points clés.
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.contentÉtape 4: Traiter un lot de vidéos
Exécuter le pipeline complet sur plusieurs vidéos et enregistrer les résultats dans un fichier 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)Exemple 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))Exemple 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);Sortie attendue
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.