Comment utiliser l'API Vidiome pour automatiser la génération d'articles depuis une vidéo
Tutoriel technique pour les développeurs : utilisez l'endpoint POST /api/v1/articles de Vidiome pour automatiser la génération d'articles vidéo à grande échelle. Exemples curl et Node.js inclus.
L'API REST publique de Vidiome permet aux développeurs d'automatiser le pipeline complet vidéo-vers-article de manière programmatique — sans navigateur, sans upload manuel. Une seule requête POST /api/v1/articles retourne un article de blog structuré et optimisé pour le SEO depuis n'importe quelle URL YouTube ou fichier vidéo.
Ce tutoriel couvre la spécification de l'endpoint, l'authentification, des exemples de code en curl et Node.js, des patterns d'usage pour le traitement par lot et l'intégration CMS, ainsi qu'un schéma de workflow d'automatisation.
À qui s'adresse ce tutoriel
- Développeurs SaaS construisant des fonctionnalités d'automatisation de contenu pour des clients ou des outils internes
- Agences de contenu traitant 20+ vidéos par semaine et souhaitant éliminer l'usage manuel de Vidiome
- Équipes plateforme intégrant le pipeline vidéo-vers-article dans un CMS ou workflow de contenu existant
- Startups construisant sur les capacités de Vidiome comme couche d'infrastructure de contenu
Si vous êtes un créateur individuel plutôt qu'un développeur, l'application web Vidiome est le chemin le plus rapide — ce tutoriel est spécifiquement destiné à l'usage programmatique de l'API.
Vidiome
Turn your videos into SEO traffic machines
Générer mon premier articleSans carte bancaire · 120 crédits offerts
Prérequis
- Un compte Vidiome avec au moins le forfait Starter (l'accès API nécessite un forfait payant ou d'essai)
- Votre clé API Vidiome (accessible dans Paramètres du compte → Clés API)
- Une connaissance de base des API REST HTTP et de curl ou Node.js
Vidiome offre 120 crédits gratuits à l'inscription — vous pouvez tester le workflow via l'application web avant de vous engager dans une intégration API.
Vue d'ensemble de l'endpoint : POST /api/v1/articles
L'endpoint de génération d'articles de Vidiome accepte une source vidéo et des paramètres de génération, puis retourne un objet article complet.
Requête
POST https://vidiome.com/api/v1/articles
Content-Type: application/json
Authorization: Bearer YOUR_API_KEY
Corps de la requête
{
"source": {
"type": "youtube_url",
"url": "https://www.youtube.com/watch?v=XXXXXXXXXXX"
},
"generation": {
"language": "fr",
"focus_keyword": "comment convertir une vidéo YouTube en article de blog",
"output_format": "markdown"
}
}
Objet source
| Champ | Type | Requis | Description |
|---|---|---|---|
type |
string | Oui | "youtube_url" ou "file_upload" |
url |
string | Requis si type = youtube_url |
URL complète de la vidéo YouTube |
file_id |
string | Requis si type = "file_upload" |
ID de fichier issu d'un upload préalable via /api/v1/files |
Objet generation
| Champ | Type | Requis | Description |
|---|---|---|---|
language |
string | Oui | Code ISO 639-1. Supportés : en, fr, es, pt, de, ru, hi, uk, id, tr |
focus_keyword |
string | Non | Mot-clé SEO cible — améliore l'alignement du H1 et de la méta |
output_format |
string | Non | "markdown" (par défaut) ou "html" |
Réponse
{
"id": "art_01HZXXX",
"status": "completed",
"created_at": "2026-05-15T10:23:41Z",
"processing_time_seconds": 187,
"credits_used": 12,
"article": {
"title": "Comment convertir une vidéo YouTube en article de blog en 5 minutes",
"meta_description": "Vidiome convertit n'importe quelle URL YouTube en article de blog SEO structuré en moins de 5 minutes. Tutoriel étape par étape avec transcription Whisper à 95 %+ de précision.",
"content": "# Comment convertir une vidéo YouTube...\n\n## Ce dont vous avez besoin\n...",
"word_count": 1247,
"language": "fr",
"focus_keyword": "comment convertir une vidéo YouTube en article de blog"
},
"transcript": {
"text": "Bonjour à tous, aujourd'hui je vais vous montrer...",
"segments": [
{ "start": 0.0, "end": 4.2, "text": "Bonjour à tous, aujourd'hui je vais vous montrer" },
...
]
}
}
Valeurs de statut
| Statut | Signification |
|---|---|
queued |
Requête acceptée, traitement non commencé |
processing |
Transcription et/ou génération d'article en cours |
completed |
Article disponible dans le corps de la réponse |
failed |
Erreur de traitement — voir le champ error |
Pour le polling asynchrone, utilisez GET /api/v1/articles/{id} avec l'id retourné.
Exemples de code
curl
curl -X POST https://vidiome.com/api/v1/articles \
-H "Content-Type: application/json" \
-H "Authorization: Bearer YOUR_API_KEY" \
-d '{
"source": {
"type": "youtube_url",
"url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
},
"generation": {
"language": "fr",
"focus_keyword": "stratégie de recyclage de contenu",
"output_format": "markdown"
}
}'
Polling pour attendre la complétion :
# Remplacez art_01HZXXX par l'id de la réponse initiale
curl -H "Authorization: Bearer YOUR_API_KEY" \
https://vidiome.com/api/v1/articles/art_01HZXXX
Node.js (fetch)
const VIDIOME_API_KEY = process.env.VIDIOME_API_KEY;
async function generateArticle(youtubeUrl, focusKeyword, language = 'fr') {
// Étape 1 : Soumettre la requête de génération d'article
const response = await fetch('https://vidiome.com/api/v1/articles', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
'Authorization': `Bearer ${VIDIOME_API_KEY}`,
},
body: JSON.stringify({
source: {
type: 'youtube_url',
url: youtubeUrl,
},
generation: {
language,
focus_keyword: focusKeyword,
output_format: 'markdown',
},
}),
});
const job = await response.json();
if (!response.ok) {
throw new Error(`Erreur API Vidiome : ${job.message}`);
}
// Étape 2 : Poller jusqu'à la complétion
return await pollUntilComplete(job.id);
}
async function pollUntilComplete(articleId, maxAttempts = 30, intervalMs = 10000) {
for (let attempt = 0; attempt < maxAttempts; attempt++) {
await new Promise(resolve => setTimeout(resolve, intervalMs));
const res = await fetch(`https://vidiome.com/api/v1/articles/${articleId}`, {
headers: { 'Authorization': `Bearer ${VIDIOME_API_KEY}` },
});
const article = await res.json();
if (article.status === 'completed') {
return article;
}
if (article.status === 'failed') {
throw new Error(`Échec de la génération d'article : ${article.error}`);
}
console.log(`[Vidiome] Statut : ${article.status} (tentative ${attempt + 1}/${maxAttempts})`);
}
throw new Error('Vidiome : délai de polling dépassé');
}
// Utilisation
const result = await generateArticle(
'https://www.youtube.com/watch?v=XXXXXXXXXXX',
'comment recycler du contenu vidéo'
);
console.log(result.article.title);
console.log(`Nombre de mots : ${result.article.word_count}`);
console.log(`Crédits utilisés : ${result.credits_used}`);
// Écrire dans un fichier, pousser vers le CMS, etc.
Schéma du workflow d'automatisation
Voici l'architecture d'automatisation complète pour un pipeline de traitement par lot typique utilisant Vidiome :
┌─────────────────────────────────────────────────────────┐
│ COUCHE SOURCE VIDÉO │
│ Playlist YouTube / flux RSS / bibliothèque vidéo CMS │
└──────────────────────┬──────────────────────────────────┘
│ URLs vidéo / références fichiers
▼
┌─────────────────────────────────────────────────────────┐
│ COUCHE D'ORCHESTRATION │
│ Tâche cron / déclencheur webhook / n8n / Make.com │
│ - Déduplication (ignorer les URLs déjà traitées) │
│ - Limitation de débit (respecter le budget crédits) │
│ - Gestion de la file d'attente │
└──────────────────────┬──────────────────────────────────┘
│ POST /api/v1/articles
▼
┌─────────────────────────────────────────────────────────┐
│ API VIDIOME │
│ 1. Transcription Whisper (segments 60 s, 95 %+ préc.) │
│ 2. Génération d'article LLM (structure + SEO) │
│ 3. Retourne : titre, méta, contenu (MD/HTML), transcript│
└──────────────────────┬──────────────────────────────────┘
│ Objet article complété
▼
┌─────────────────────────────────────────────────────────┐
│ COUCHE POST-TRAITEMENT │
│ - File de relecture humaine (optionnelle mais conseillée)│
│ - Injection de liens internes (ajout de liens existants)│
│ - Attribution d'image à la une │
│ - Injection de balisage schema (Article JSON-LD) │
└──────────────────────┬──────────────────────────────────┘
│ Article prêt à publier
▼
┌─────────────────────────────────────────────────────────┐
│ CMS / PLATEFORME │
│ WordPress (REST API) / Ghost (Admin API) │
│ Webflow CMS / Contentful / Sanity / BDD personnalisée │
└─────────────────────────────────────────────────────────┘
Cas d'usage
Traitement par lot d'une chaîne YouTube
Traiter l'intégralité du back-catalogue d'une chaîne YouTube en une seule exécution :
async function processYouTubeChannel(channelVideoUrls, options = {}) {
const {
language = 'fr',
concurrency = 3, // max requêtes Vidiome en parallèle
delayMs = 2000, // délai entre les lots (limitation de débit)
} = options;
const results = [];
// Traiter par lots de `concurrency`
for (let i = 0; i < channelVideoUrls.length; i += concurrency) {
const batch = channelVideoUrls.slice(i, i + concurrency);
const batchResults = await Promise.allSettled(
batch.map(url => generateArticle(url, '', language))
);
results.push(...batchResults);
console.log(`Traité ${Math.min(i + concurrency, channelVideoUrls.length)}/${channelVideoUrls.length} vidéos`);
if (i + concurrency < channelVideoUrls.length) {
await new Promise(resolve => setTimeout(resolve, delayMs));
}
}
return results;
}
Une chaîne avec 100 vidéos traitées à 3 requêtes concurrentes : environ 100 minutes au total (moyenne 3 minutes par vidéo × 100 ÷ 3 en parallèle).
Intégration CMS (exemple WordPress)
Après que Vidiome retourne l'article, publiez-le directement sur WordPress via l'API REST :
async function publishToWordPress(vidiomeArticle, wpConfig) {
const { siteUrl, username, appPassword } = wpConfig;
const credentials = Buffer.from(`${username}:${appPassword}`).toString('base64');
const response = await fetch(`${siteUrl}/wp-json/wp/v2/posts`, {
method: 'POST',
headers: {
'Content-Type': 'application/json',
'Authorization': `Basic ${credentials}`,
},
body: JSON.stringify({
title: vidiomeArticle.article.title,
content: vidiomeArticle.article.content, // Format HTML recommandé pour WP
excerpt: vidiomeArticle.article.meta_description,
status: 'draft', // Toujours en brouillon d'abord pour relecture humaine
}),
});
return await response.json();
}
Lot multilingue : une vidéo, 10 langues
Générer le même article dans les 10 langues supportées simultanément :
const SUPPORTED_LANGUAGES = ['en', 'fr', 'es', 'pt', 'de', 'ru', 'hi', 'uk', 'id', 'tr'];
async function generateMultilingual(youtubeUrl, focusKeywords = {}) {
const requests = SUPPORTED_LANGUAGES.map(lang =>
generateArticle(
youtubeUrl,
focusKeywords[lang] || focusKeywords['fr'] || '',
lang
)
);
// Lancer les 10 langues en parallèle
const results = await Promise.allSettled(requests);
return results.reduce((acc, result, index) => {
const lang = SUPPORTED_LANGUAGES[index];
if (result.status === 'fulfilled') {
acc[lang] = result.value;
} else {
console.error(`Échec pour ${lang} :`, result.reason);
}
return acc;
}, {});
}
Cela génère 10 versions linguistiques d'une seule vidéo en environ 5 à 8 minutes (traitement parallèle).
Limites de débit et gestion du budget crédits
| Forfait | Limite de débit API | Crédits/mois |
|---|---|---|
| Gratuit (120 crédits) | 2 req/min | 120 (une seule fois) |
| Starter | 10 req/min | Selon le forfait |
| Pro | 30 req/min | Selon le forfait |
| Agency | 60 req/min | Selon le forfait |
Consommation de crédits : chaque génération d'article utilise 10 à 15 crédits selon la durée de la vidéo. Une vidéo de 10 minutes consomme environ 10 crédits ; une vidéo de 60 minutes consomme environ 15 crédits.
Recommandation budgétaire pour le traitement par lot : estimez ceil(durée_vidéo_minutes / 4) + 10 crédits par vidéo comme budget conservateur.
Gestion des erreurs
L'API Vidiome utilise les codes de statut HTTP standard :
| Code | Signification | Action |
|---|---|---|
200 |
Succès | Traiter la réponse |
400 |
Requête invalide (mauvaise URL, langue non supportée, etc.) | Corriger les paramètres |
401 |
Clé API invalide ou manquante | Vérifier l'en-tête Authorization |
402 |
Crédits insuffisants | Recharger le compte ou réduire la taille du lot |
429 |
Limite de débit dépassée | Implémenter un backoff exponentiel |
500 |
Erreur serveur | Réessayer avec backoff exponentiel (max 3 tentatives) |
Questions fréquentes
L'API Vidiome supporte-t-elle les uploads de fichiers, ou uniquement les URLs YouTube ?
L'API Vidiome supporte à la fois les URLs YouTube et les uploads directs de fichiers. Pour les uploads, appelez d'abord POST /api/v1/files avec votre fichier vidéo (MP4, MOV ou WebM, jusqu'à 2 Go), récupérez un file_id, puis passez ce file_id à POST /api/v1/articles avec "type": "file_upload". Cela est utile pour traiter des vidéos non hébergées sur YouTube — enregistrements de webinaires, vidéos Loom, contenu de formation interne et vidéos hébergées sur Vimeo.
Comment gérer les vidéos longues (60+ minutes) via l'API ?
Vidiome traite des vidéos allant jusqu'à 4 heures via l'API. Pour les vidéos de plus de 60 minutes, la réponse API est asynchrone par défaut — vous recevez un id de job immédiatement, puis vous interrogez GET /api/v1/articles/{id} toutes les 15 à 30 secondes jusqu'à ce que le statut soit completed. Une vidéo de 90 minutes est généralement traitée en 6 à 9 minutes. L'architecture de découpage audio en segments de 60 secondes de Vidiome signifie que même les vidéos très longues ne rencontrent pas de problèmes de timeout.
Existe-t-il une option webhook plutôt que le polling ?
Oui. Vidiome supporte les callbacks webhook pour la complétion d'article. Ajoutez un champ "webhook_url" dans le corps de votre requête POST pointant vers votre endpoint, et Vidiome enverra une requête POST avec l'objet article complet lorsque le traitement sera terminé — éliminant le besoin de polling. Le payload du webhook est identique au format de réponse de GET /api/v1/articles/{id}.
Prochaines étapes
Vidiome
Turn your videos into SEO traffic machines
Générer mon premier articleSans carte bancaire · 120 crédits offerts