Skip to Content

Automatizando tu flujo de video con la API Snapencode

Aprende a crear un pipeline de video completamente automatizado, desde la subida hasta el procesamiento y entrega, utilizando la API client-facing de Snapencode y un script simple de Node.js.

por
TS
The Snapencode Team
•
Hero image for Automatizando tu flujo de video con la API Snapencode

En el mundo actual dominado por contenido, la subida manual de videos y su procesamiento pueden ser una importante barrera, ralentizando todo tu pipeline de contenido. El verdadero poder de una plataforma como Snapencode reside en su diseño basado en API, que permite automatizar estas tareas repetitivas y recuperar tiempo valioso.

En este tutorial, crearemos un script práctico “watch folder” que monitoree un directorio para nuevos archivos de video, los suba automáticamente a Snapencode y confirme su estado de procesamiento.

El Objetivo: Un Subidor de Folders “Watch”

Nuestro objetivo es crear un script de Node.js que logre lo siguiente:

  1. Monitorea un directorio específico en una máquina local o servidor.
  2. Cuando se agrega un nuevo archivo de video (.mp4, .mov, etc.), lo sube automáticamente a una colección designada en Snapencode.
  3. Después de la subida, pide el estado del endpoint hasta que el video esté “completado”.
  4. Una vez completado, registra el ID del video y está listo para el siguiente archivo.

Esta es una solución perfecta para flujos de trabajo donde el contenido se genera programáticamente o se coloca en un directorio compartido por miembros no técnicos del equipo.

Requisitos previos

  • Una clave API de Snapencode: Generela desde tu panel bajo Configuración > Claves API.
  • Node.js: Usaremos JavaScript y el runtime Node.js para nuestro script.
  • axios y chokidar: Dos paquetes simples para hacer solicitudes a la API y vigilar archivos.
npm install axios chokidar form-data

Creando el Script de Automatización

Crearémos un solo script completo. Llamémoslo upload-watcher.js.

Paso 1: Configurar el Script

Primero, establezcamos las variables de configuración y importemos las bibliotecas necesarias en la parte superior de nuestro archivo 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');
 
// --- Configuración ---
const API_BASE_URL = 'https://tu-dominio-de-snapencode.com/api/client/v1';
const API_KEY = process.env.Snapencode_API_KEY || 'sk_tu_llave_api_aqui'; // Mejor práctica: usa variables de entorno
const TARGET_FOLDER = 'raíz/automatizados-cargados'; // La ruta de la colección en Snapencode
const WATCH_DIRECTORY = './videos-para-subir';
 
// Un conjunto para mantener el seguimiento de los archivos que se están procesando para evitar subidas dobles
const processingFiles = new Set();

Usar variables de entorno (process.env.Snapencode_API_KEY) para tu clave API es mucho más seguro que codificarla directamente en el script.

Paso 2: Crear las Funciones Principales

A continuación, agreguemos las dos funciones principales: una para manejar la subida del archivo y otra para monitorear el estado de procesamiento.

upload-watcher.js
// (Agrega este código debajo de la sección de configuración)
 
async function uploadVideo(filePath) {
console.log(`[SUBIENDO] Comenzando subida para: ${path.basename(filePath)}`);
processingFiles.add(filePath); // Marcar archivo como siendo procesado
 
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(`[ÉXITO] La subida se aceptó! ID del video: ${response.data.data.id}`);
return response.data.data.id;
} catch (error) {
console.error(`[FALLA] La subida falló para ${path.basename(filePath)}:`, error.response?.data?.message || error.message);
return null;
}
}
 
async function monitorStatus(videoId, filePath) {
if (!videoId) {
processingFiles.delete(filePath); // Eliminar del conjunto de procesamiento en caso de falla
return;
}
 
console.log(`[MONITOREO] Observando estado para ID del video: ${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) { // Completado
console.log(`✅ [COMPLETADO] El procesamiento terminó para ID del video: ${videoId}!`);
clearInterval(interval);
processingFiles.delete(filePath); // Eliminar del conjunto en éxito
} else if (status === 7) { // Fallido
console.error(`❌ [FALLIDO] El procesamiento falló para ID del video: ${videoId}.`);
clearInterval(interval);
processingFiles.delete(filePath);
} else {
console.log(`[ESTADO] ID del video ${videoId}: ${status_text} (${status})`);
}
} catch (error) {
console.error(`[ERROR] No se pudo obtener el estado para ${videoId}:`, error.message);
clearInterval(interval);
processingFiles.delete(filePath);
}
}, 5000); // Verificar cada 5 segundos
}

Este script demuestra una interacción servidor a servidor. Nunca expungas tu clave secreta en código de cliente.

Paso 3: Inicializar el Vigilante de Archivos

Finalmente, agreguemos la lógica de chokidar al final del script. Esto vigilará el directorio y desencadenará nuestras funciones cuando se agrega un nuevo archivo.

upload-watcher.js
// (Agrega este código al final del archivo)
 
function initializeWatcher() {
console.log(`--- Snapencode Watch Folder Inicializado ---`);
console.log(`Vigilando nuevos videos en: ${path.resolve(WATCH_DIRECTORY)}`);
 
if (!fs.existsSync(WATCH_DIRECTORY)) {
console.log(`Creando directorio de vigilancia...`);
fs.mkdirSync(WATCH_DIRECTORY, { recursive: true });
}
 
const watcher = chokidar.watch(WATCH_DIRECTORY, {
ignored: /(^|[\/\\])\../, // Ignorar archivos ocultos
persistent: true,
ignoreInitial: true, // No subir archivos que ya están allí al arrancar
});
 
watcher.on('add', (filePath) => {
if (processingFiles.has(filePath)) {
return; // Saltar si ya está siendo procesado
}
console.log(`[DETECTADO] Nuevo archivo: ${path.basename(filePath)}`);
// Espera un momento para asegurarse de que el archivo esté completamente escrito antes de subirlo
setTimeout(async () => {
const videoId = await uploadVideo(filePath);
await monitorStatus(videoId, filePath);
}, 2000);
});
}
 
initializeWatcher();

Paso 4: Ejecutar tu Vigilante

Con el archivo upload-watcher.js completo, puedes ejecutarlo desde tu terminal.

# Mejor práctica: establece la clave API como variable de entorno
export Snapencode_API_KEY="sk_tu_llave_api_aqui"
 
# Ejecuta el script
node upload-watcher.js

Ahora, cualquier nuevo archivo de video que coloques en el directorio ./videos-para-subir se subirá y procesará automáticamente!