Skip to Content

Automatiser votre flux de vidéo avec l'API Snapencode

Apprenez à créer un pipeline vidéo entièrement automatisé, depuis l'importation jusqu'à la livraison, en utilisant l'API client-facing Snapencode et un script Node.js simple.

par
TS
The Snapencode Team
•
Hero image for Automatiser votre flux de vidéo avec l'API Snapencode

Dans un monde où le contenu est la priorité, l’upload manuel de vidéos et leur traitement peuvent être une brique importante, ralentissant ainsi tout votre pipeline de contenu. Le véritable pouvoir d’une plateforme comme Snapencode réside dans son design API-first, qui permet de automatiser ces tâches répétitives et récupérer du temps précieux.

Dans ce tutoriel, nous allons créer une script pratique « watch folder » qui surveille un dossier pour les nouveaux fichiers vidéo, les upload automatiquement à Snapencode et confirme leur statut de traitement.

L’objectif : Un “Watch Folder” Uploader

Notre objectif est de créer un script Node.js qui atteint les points suivants :

  1. Surveille un dossier spécifique sur une machine locale ou serveur.
  2. Lorsqu’un nouveau fichier vidéo (.mp4, .mov, etc.) est ajouté, il upload automatiquement ce dernier dans une collection dédiée à Snapencode.
  3. Après l’upload, il poll le endpoint de statut jusqu’à ce que la vidéo soit “terminée.”
  4. Une fois terminée, il enregistre l’ID de la vidéo et est prêt pour le prochain fichier.

C’est une solution parfaite pour les workflows où le contenu est généré programmationnellement ou déposé dans un dossier partagé par des membres non techniques.

Prérequis

  • Une clé API Snapencode : Générez-en une à partir de votre tableau de bord sous Paramètres > Clés API.
  • Node.js : Nous utiliserons JavaScript et le runtime Node.js pour notre script.
  • axios et chokidar: Deux packages simples pour faire des requêtes API et surveiller les fichiers.
npm install axios chokidar form-data

Construction de la script d’automatisation

Nous allons créer une seule et même script. Appelons-le upload-watcher.js.

Étape 1 : Configuration du Script

Tout d’abord, mettons en place les variables de configuration et importons les bibliothèques nécessaires en haut de notre fichier upload-watcher.js.

upload-watcher.js
const axios = require('axios');
const FormData = require('form-data');
const fs = require('fs');
const path = require('path');
const chokidar = require('chokidar');
 
// --- Configuration ---
const API_BASE_URL = 'https://votre-domaine-snapencode.com/api/client/v1';
const API_KEY = process.env.Snapencode_API_KEY || 'sk_votre_clé_api_ici'; // Meilleure pratique : utilisez les variables d'environnement
const TARGET_FOLDER = 'root/automated-uploads'; // Le chemin de la collection dans Snapencode
const WATCH_DIRECTORY = './videos-to-upload';
 
// Un ensemble pour suivre les fichiers en cours de traitement afin d'éviter les uploads doubles
const processingFiles = new Set();

L’utilisation des variables d’environnement (process.env.Snapencode_API_KEY) pour votre clé API est beaucoup plus sécurisée que la codification directe dans le script.

Étape 2 : Création des fonctions principales

Ensuite, ajoutez les deux fonctions principales : une pour gérer l’upload du fichier et l’autre pour surveiller le statut de traitement.

upload-watcher.js
// (Ajoutez ce code en dessous de la section de configuration)
 
async function uploadVideo(filePath) {
console.log(`[UPLOADING] Début de l'upload pour : ${path.basename(filePath)}`);
processingFiles.add(filePath); // Marque le fichier comme étant en cours de traitement
 
const form = new FormData();
form.append('video', fs.createReadStream(filePath));
form.append('folder', TARGET_FOLDER);
 
try {
const response = await axios.post(`${API_BASE_URL}/uploads`, form, {
headers: { ...form.getHeaders(), 'Authorization': `Bearer ${API_KEY}` },
});
console.log(`[SUCCESS] L'upload a été accepté ! ID de la vidéo : ${response.data.data.id}`);
return response.data.data.id;
} catch (error) {
console.error(`[FAILURE] L'upload a échoué pour ${path.basename(filePath)} :`, error.response?.data?.message || error.message);
return null;
}
}
 
async function monitorStatus(videoId, filePath) {
if (!videoId) {
processingFiles.delete(filePath); // Supprime du ensemble de traitement en cas d'échec
return;
}
 
console.log(`[MONITORING] Surveillance du statut pour la Vidéo ID : ${videoId}`);
const interval = setInterval(async () => {
try {
const response = await axios.get(`${API_BASE_URL}/uploads/${videoId}`, {
headers: { 'Authorization': `Bearer ${API_KEY}` },
});
const { status, status_text } = response.data.data;
 
if (status === 6) { // Terminé
console.log(`✅ [COMPLETE] Le traitement a été terminé pour la Vidéo ID : ${videoId} !`);
clearInterval(interval);
processingFiles.delete(filePath); // Supprime du ensemble de traitement en cas de réussite
} else if (status === 7) { // Échoué
console.error(`❌ [FAILED] Le traitement a échoué pour la Vidéo ID : ${videoId}.`);
clearInterval(interval);
processingFiles.delete(filePath);
} else {
console.log(`[STATUS] Vidéo ID ${videoId}: ${status_text} (${status})`);
}
} catch (error) {
console.error(`[ERROR] Impossible de récupérer le statut pour ${videoId}:`, error.message);
clearInterval(interval);
processingFiles.delete(filePath);
}
}, 5000); // Vérifie tous les 5 secondes
}

Ce script démontre une interaction serveur-serveur. Jamais exposez votre clé API dans le code client.

Étape 3 : Initialisation du surveillant de fichiers

Enfin, ajoutez la logique chokidar en fin de script. Cela surveillera le dossier et déclenchera nos fonctions lorsque un nouveau fichier est ajouté.

upload-watcher.js
// (Ajoutez ce code à la fin du fichier)
 
function initializeWatcher() {
console.log(`--- Snapencode Watch Folder Initialement ---`);
console.log(`Surveillance de nouveaux fichiers dans : ${path.resolve(WATCH_DIRECTORY)}`);
 
if (!fs.existsSync(WATCH_DIRECTORY)) {
console.log(`Création du dossier de surveillance...`);
fs.mkdirSync(WATCH_DIRECTORY, { recursive: true });
}
 
const watcher = chokidar.watch(WATCH_DIRECTORY, {
ignored: /(^|[\/\\])\../, // Ignore les fichiers cachés
persistent: true,
ignoreInitial: true, // Ne charge pas les fichiers qui sont déjà présents au démarrage
});
 
watcher.on('add', (filePath) => {
if (processingFiles.has(filePath)) {
return; // Passe si déjà en cours de traitement
}
console.log(`[DETECTED] Nouveau fichier : ${path.basename(filePath)}`);
// Attends un moment pour s'assurer que le fichier est complètement écrit avant l'upload
setTimeout(async () => {
const videoId = await uploadVideo(filePath);
await monitorStatus(videoId, filePath);
}, 2000);
});
}
 
initializeWatcher();

Étape 4 : Lancement de votre surveillant

Avec le fichier upload-watcher.js complet, vous pouvez lancer la commande dans votre terminal.

# Meilleure pratique : définissez la clé API comme variable d'environnement
export Snapencode_API_KEY="sk_votre_clé_api_ici"
 
# Lancement du script
node upload-watcher.js

Maintenant, tout nouveau fichier vidéo que vous déposez dans le dossier ./videos-to-upload sera automatiquement uploadé et traité !