Skip to Content

Automatiseren van uw video workflow met de Snapencode API

Leer hoe u een volledig geautomatiseerde videopijplijn kunt opzetten, van uploaden tot verwerking en aflevering, met behulp van de client-facing API van Snapencode en een eenvoudige Node.js script.

door
TS
The Snapencode Team
•
Hero image for Automatiseren van uw video workflow met de Snapencode API

In de huidige content-gerichte wereld kan het manuele uploaden en verwerken van video’s een significante bottleneck zijn, waardoor je hele content-pijplijn wordt vertraagd. Het echte potentieel van een platform als Snapencode ligt in zijn API-first ontwerp, wat deze herhalende taken automatisch laat uitvoeren en waardevolle tijd terugwint.

In dit tutorial bouwen we een praktische “watch folder” script dat een map monitort voor nieuwe video-bestanden, ze automatisch uploadt naar Snapencode en hun verwerkingstatus bevestigt.

Het Doel: Een “Watch Folder”-Uploader

Ons doel is om een Node.js-script te maken dat de volgende taken uitvoert:

  1. Eén of meer bestandsmap op een lokale machine of server monitort.
  2. Wanneer er een nieuwe video-bestand (.mp4, .mov, etc.) wordt toegevoegd, uploadt het automatisch naar een bepaalde collectie in Snapencode.
  3. Naar de upload volgt een polling van de status-endpoint totdat de video “afgerond” is.
  4. Zodra afgerond is, logt het de video-ID en is klaar voor de volgende bestand.

Dit is een perfecte oplossing voor workflows waar content programmatisch wordt gegenereerd of in een gedeelde map wordt gedropt door niet-technische teamleden.

Voorwaarden

  • Een Snapencode API-sleutel: Maak er eentje aan vanuit je dashboard onder Instellingen > API-Sleutels.
  • Node.js: We zullen JavaScript en de Node.js runtime gebruiken voor ons script.
  • axios en chokidar: Twee simpele pakketten voor het maken van API-verzoeken en bestanden bewaken.
npm install axios chokidar form-data

Het Script Bouwen

We zullen een enkel, compleet script creëren. Laten we hem upload-watcher.js noemen.

Stap 1: Configuratie van het Script

Eerst stellen we de configuratieve variabelen in en importeren we de benodigde bibliotheken aan de bovenkant van ons upload-watcher.js bestand.

upload-watcher.js
import axios from 'axios';
import FormData from 'form-data';
import fs from 'fs';
import path from 'path';
import chokidar from 'chokidar';
 
// --- Configuratie ---
const API_BASE_URL = 'https://your-Snapencode-domain.com/api/client/v1';
const API_KEY = process.env.Snapencode_API_KEY || 'sk_your_api_key_here'; // Best practice: gebruik omgevingsvariabelen
const TARGET_FOLDER = 'root/automated-uploads'; // De collectiepad in Snapencode
const WATCH_DIRECTORY = './videos-to-upload';
 
// Een set om bestanden te bewaren die momenteel worden verwerkt, om dubbele uploads te voorkomen
const processingFiles = new Set();

Het gebruik van omgevingsvariabelen (process.env.Snapencode_API_KEY) voor je API-sleutel is veel veiliger dan deze rechtstreeks in het script te coderen.

Stap 2: De Core Functies Creëren

Volgende voegen we de twee belangrijkste functies toe: één voor het uploaden van bestanden en een andere voor het monitoren van de verwerkingstatus.

upload-watcher.js
// (Voeg deze code onder de configuratie sectie toe)
 
async function uploadVideo(filePath) {
console.log(`[UPLOADEN] Upload starten voor: ${path.basename(filePath)}`);
processingFiles.add(filePath); // Markeer bestand als in verwerking
 
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(`[SUCCES] Upload aanvaard! Video ID: ${response.data.data.id}`);
return response.data.data.id;
} catch (error) {
console.error(`[FAILURE] Upload mislukt voor ${path.basename(filePath)}:`, error.response?.data?.message || error.message);
return null;
}
}
 
async function monitorStatus(videoId, filePath) {
if (!videoId) {
processingFiles.delete(filePath); // Verwijder uit verwerkingset bij falen
return;
}
 
console.log(`[MONITOREN] Status bewaken voor Video 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) { // Afgerond
console.log(`✅ [AFGEROND] Verwerking voltooid voor Video ID: ${videoId}!`);
clearInterval(interval);
processingFiles.delete(filePath); // Verwijder uit set bij succes
} else if (status === 7) { // Mislukt
console.error(`❌ [MISLUKT] Verwerking mislukt voor Video ID: ${videoId}.`);
clearInterval(interval);
processingFiles.delete(filePath);
} else {
console.log(`[STATUS] Video ID ${videoId}: ${status_text} (${status})`);
}
} catch (error) {
console.error(`[ERROR] Kon status niet ophalen voor ${videoId}:`, error.message);
clearInterval(interval);
processingFiles.delete(filePath);
}
}, 5000); // Controleer elke 5 seconden
}

Dit script demonstreert een server-naar-server interactie. Nooit je geheime API-sleutel in client-side browser code blootstellen.

Stap 3: De Bestandsbewaker Initialiseren

Ten slotte voegen we de chokidar logica toe aan het einde van het script. Dit zal de map bewaken en onze functies activeren wanneer er een nieuw bestand wordt toegevoegd.

upload-watcher.js
// (Voeg deze code aan het einde van het bestand toe)
 
function initializeWatcher() {
console.log(`--- Snapencode Watch Folder Geïnitieerd ---`);
console.log(`Bewaken voor nieuwe video-bestanden in: ${path.resolve(WATCH_DIRECTORY)}`);
 
if (!fs.existsSync(WATCH_DIRECTORY)) {
console.log(`Map aanmaken...`);
fs.mkdirSync(WATCH_DIRECTORY, { recursive: true });
}
 
const watcher = chokidar.watch(WATCH_DIRECTORY, {
ignored: /(^|[\/\\])\../, // Ignore dotfiles
persistent: true,
ignoreInitial: true, // Upload bestanden die al aanwezig zijn bij starten niet
});
 
watcher.on('add', (filePath) => {
if (processingFiles.has(filePath)) {
return; // Overslaan als reeds in verwerking
}
console.log(`[DETEKT] Nieuw bestand: ${path.basename(filePath)}`);
// Wacht even om te zorgen dat het bestand volledig geschreven is voordat geüpload wordt
setTimeout(async () => {
const videoId = await uploadVideo(filePath);
await monitorStatus(videoId, filePath);
}, 2000);
});
}
 
initializeWatcher();

Stap 4: Het Script Uitvoeren

Met het upload-watcher.js bestand compleet kunt u het vanuit uw terminal uitvoeren.

# Best practice: stel de API-sleutel in als omgevingsvariabele
export Snapencode_API_KEY="sk_your_api_key_here"
 
# Uitvoeren van het script
node upload-watcher.js

Nu worden alle nieuwe video-bestanden die u in de ./videos-to-upload directory plaatst automatisch geüpload en verwerkt!