Skip to Content

Automatizando o Fluxo de Trabalho com Vídeo com a API do Snapencode

Aprenda a criar um fluxo de trabalho automatizado de vídeo, desde o upload até a processamento e entrega, usando a API do cliente da Snapencode e um script simples em Node.js.

por
TS
The Snapencode Team
•
Hero image for Automatizando o Fluxo de Trabalho com Vídeo com a API do Snapencode

Em um mundo atualmente focado em conteúdo, a upload e processamento manual de vídeos pode ser uma grande barreira, atrasando todo o pipeline de conteúdo. O verdadeiro poder de uma plataforma como Snapencode está na sua design baseado em API, que permite automatizar essas tarefas repetitivas e reaver tempo valioso.

Neste tutorial, vamos construir um script prático “watch folder” que monitora um diretório para novos arquivos de vídeo, os carrega automaticamente para o Snapencode e confirma seu status de processamento.

O Objetivo: Um Upload Automático com “Watch Folder”

Nosso objetivo é criar um script Node.js que atinja os seguintes objetivos:

  1. Monitore um diretório específico em uma máquina local ou servidor.
  2. Quando um novo arquivo de vídeo (.mp4, .mov, etc.) for adicionado, ele carregue-o automaticamente para uma coleção designada no Snapencode.
  3. Após o upload, ele faça uma solicitação ao endpoint de status até que o vídeo esteja “concluído”.
  4. Uma vez concluído, ele registre o ID do vídeo e estiver pronto para o próximo arquivo.

Essa é a solução perfeita para fluxos de trabalho onde conteúdo é gerado programaticamente ou adicionado em uma pasta compartilhada por membros não técnicos da equipe.

Pré-requisitos

  • Uma Chave de API do Snapencode: Gere uma chave na sua área de configuração sob Configurações > Chaves de API.
  • Node.js: Usaremos JavaScript e o runtime Node.js para nosso script.
  • axios e chokidar: Dois pacotes simples para fazer solicitações de API e assistir a arquivos.
npm install axios chokidar form-data

Construindo o Script de Automatização

Vamos criar um único script completo. Vamos nomeá-lo upload-watcher.js.

Passo 1: Configure o Script

Primeiro, vamos configurar as variáveis de configuração e importar as bibliotecas necessárias no topo do nosso arquivo 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');
 
// --- Configuração ---
const API_BASE_URL = 'https://seu-dominio-do-snapencode.com/api/client/v1';
const API_KEY = process.env.Snapencode_API_KEY || 'sk_seu_chave_api_aqui'; // Prática recomendada: use variáveis de ambiente
const TARGET_FOLDER = 'raiz/automated-uploads'; // O caminho da coleção no Snapencode
const WATCH_DIRECTORY = './videos-to-upload';
 
// Um conjunto para manter o registro dos arquivos atualmente sendo processados para evitar uploads duplicados
const processingFiles = new Set();

Usar variáveis de ambiente (process.env.Snapencode_API_KEY) para sua chave de API é muito mais seguro do que codificá-la diretamente no script.

Passo 2: Crie as Funções Principais

Em seguida, adicione as duas funções principais: uma para lidar com o upload do arquivo e outra para monitorar o status de processamento.

upload-watcher.js
// (Adicione esse código abaixo da seção de configuração)
 
async function uploadVideo(filePath) {
console.log(`[UPLOADANDO] Iniciando upload para: ${path.basename(filePath)}`);
processingFiles.add(filePath); // Marque o arquivo como sendo processado
 
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(`[SUCESSO] Upload aceito! ID do vídeo: ${response.data.data.id}`);
return response.data.data.id;
} catch (error) {
console.error(`[FALHA] Upload falhou para ${path.basename(filePath)}:`, error.response?.data?.message || error.message);
return null;
}
}
 
async function monitorStatus(videoId, filePath) {
if (!videoId) {
processingFiles.delete(filePath); // Remova do conjunto de processamento em caso de falha
return;
}
 
console.log(`[MONITORANDO] Observando status para ID do vídeo: ${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) { // Concluído
console.log(`✅ [CONCLUÍDO] Processamento concluído para ID do vídeo: ${videoId}!`);
clearInterval(interval);
processingFiles.delete(filePath); // Remova do conjunto em caso de sucesso
} else if (status === 7) { // Falha
console.error(`❌ [FALHA] Processamento falhou para ID do vídeo: ${videoId}.`);
clearInterval(interval);
processingFiles.delete(filePath);
} else {
console.log(`[STATUS] ID do vídeo ${videoId}: ${status_text} (${status})`);
}
} catch (error) {
console.error(`[ERRO] Não foi possível obter status para ${videoId}:`, error.message);
clearInterval(interval);
processingFiles.delete(filePath);
}
}, 5000); // Verifique a cada 5 segundos
}

Esse script demonstra uma interação servidor-servidor. Nunca expus sua chave de API em código do lado do cliente.

Passo 3: Inicie o Observador de Arquivos

Finalmente, adicione a lógica chokidar ao final do script. Isso monitorará o diretório e acionará nossas funções quando um novo arquivo for adicionado.

upload-watcher.js
// (Adicione esse código no final do arquivo)
 
function initializeWatcher() {
console.log(`--- Snapencode Watch Folder Inicializado ---`);
console.log(`Observando novos vídeos em: ${path.resolve(WATCH_DIRECTORY)}`);
 
if (!fs.existsSync(WATCH_DIRECTORY)) {
console.log(`Criando diretório de observação...`);
fs.mkdirSync(WATCH_DIRECTORY, { recursive: true });
}
 
const watcher = chokidar.watch(WATCH_DIRECTORY, {
ignored: /(^|[\/\\])\../, // ignore dotfiles
persistent: true,
ignoreInitial: true, // Não carregue arquivos que já estão lá no início
});
 
watcher.on('add', (filePath) => {
if (processingFiles.has(filePath)) {
return; // Pule se já estiver sendo processado
}
console.log(`[DETECTADO] Novo arquivo: ${path.basename(filePath)}`);
// Aguarde um momento para garantir que o arquivo esteja completamente escrito antes de carregar
setTimeout(async () => {
const videoId = await uploadVideo(filePath);
await monitorStatus(videoId, filePath);
}, 2000);
});
}
 
initializeWatcher();

Passo 4: Execute Seu Observador

Com o arquivo upload-watcher.js completo, você pode executá-lo da sua linha de comando.

# Prática recomendada: defina a chave de API como uma variável de ambiente
export Snapencode_API_KEY="sk_seu_chave_api_aqui"
 
# Execute o script
node upload-watcher.js

Agora, qualquer novo arquivo de vídeo que você adicionar na pasta ./videos-to-upload será carregado e processado automaticamente!