Whisper na VPS: instalação, configuração e escalonamento de transcrição de vídeos longos
Whisper da OpenAI pode ser instalado em qualquer VPS Linux com pelo menos 4 GB de RAM para rodar o modelo base, permitindo transcrever vídeos longos localmente sem limite de duração ou custo por minuto. A instalação exige Python 3.8+, FFmpeg para extração de áudio e a biblioteca openai-whisper, com os modelos variando de 1 GB (tiny) a 10 GB (large-v3) conforme a precisão desejada.
TL;DR: Whisper self-hosted em VPS entrega transcrição de vídeo sem cotas, com controle total de formato de saída (SRT, VTT, TXT) e custo fixo mensal, ideal para processamento em lote via n8n ou cron.
A transcrição de vídeos longos — palestras, webinars, podcasts em vídeo — costuma esbarrar em três limitações de APIs pagas: custo por minuto que escala linearmente, limite de tamanho de arquivo (geralmente 25 MB ou 2 horas) e dependência de conectividade durante o upload. Hospedar Whisper numa VPS resolve os três: o custo é fixo (a mensalidade do servidor), não há teto de duração e o processamento roda localmente, consumindo apenas CPU e RAM do próprio servidor.
Por que rodar Whisper em VPS em vez de API paga?
A comparação técnica entre Whisper self-hosted e serviços de transcrição por API revela trade-offs claros de custo, controle e esforço operacional.
Custo operacional: APIs como AssemblyAI ou Deepgram cobram entre US$ 0,10 e US$ 0,25 por minuto de áudio. Um cliente que transcreve 1.000 horas/mês (típico de produtoras de conteúdo educacional) pagaria US$ 6.000 a US$ 15.000 mensais. A mesma carga numa VPS Pro 30 da Rollin Host (8 vCPU, 16 GB RAM, R$ 259,90/mês) processa cerca de 120 horas de vídeo por dia com o modelo medium, totalizando 3.600 horas/mês por menos de R$ 300 — redução de 95% no custo recorrente.
Controle de formato e privacidade: Whisper local gera legendas em SRT, VTT, TXT ou JSON diretamente, sem necessidade de conversão. Vídeos com conteúdo sensível (jurídico, médico, corporativo) nunca saem da infraestrutura própria, atendendo requisitos de LGPD e contratos de confidencialidade sem exceções de terceiros.
Escalabilidade horizontal: Adicionar capacidade numa API significa apenas pagar mais. Numa VPS, escalar implica provisionamento de servidores adicionais (manual ou via orquestração) e gerenciamento de filas — exige conhecimento de infra, mas entrega controle absoluto sobre throughput e priorização de tarefas.
O trade-off está no esforço: APIs são plug-and-play; VPS exige setup, monitoramento e manutenção de dependências. Para volumes acima de 200 horas/mês, o investimento em infra própria compensa.
Requisitos de infraestrutura: qual VPS escolher?
Whisper oferece cinco modelos principais, cada um com perfil distinto de RAM, VRAM (se usar GPU) e precisão. A escolha do modelo define a especificação mínima da VPS.
| Modelo Whisper | Parâmetros | RAM CPU (GB) | VRAM GPU (GB) | WER (inglês) | Velocidade relativa |
|---|---|---|---|---|---|
| tiny | 39 M | 1 | ~1 | ~10% | 32× |
| base | 74 M | 1 | ~1 | ~7% | 16× |
| small | 244 M | 2 | ~2 | ~5% | 6× |
| medium | 769 M | 5 | ~5 | ~4% | 2× |
| large-v3 | 1550 M | 10 | ~10 | ~3% | 1× (referência) |
WER (Word Error Rate) mede a taxa de erro: quanto menor, melhor a precisão. Velocidade relativa compara o tempo de processamento ao modelo large-v3.
Para conteúdo em português brasileiro, o modelo medium oferece o melhor custo-benefício: precisão suficiente para legendas publicáveis (WER ~5% após ajustes) e velocidade 2× mais rápida que o large. Roda confortavelmente numa VPS Pro 20 (4 vCPU, 8 GB RAM, R$ 159,90/mês) ou, para produção com múltiplos jobs simultâneos, numa VPS Pro 30 (8 vCPU, 16 GB RAM, R$ 259,90/mês).
Quem processa apenas arquivos curtos (até 10 minutos) ou aceita transcrições "boas o suficiente" pode usar o modelo small numa VPS Lite 20 (2 vCPU, 4 GB RAM, R$ 119,90/mês). Já operações críticas (jurídico, acessibilidade) devem optar pelo large-v3 num servidor para IA com 16 GB+ RAM.
GPU acelera, mas não é obrigatória: Whisper roda em CPU pura; modelos até medium processam 1 hora de vídeo em 10-20 minutos em CPU moderna (AMD EPYC, por exemplo). GPU (CUDA) reduz isso para 2-5 minutos, mas adiciona custo significativo. Para batches noturnos, CPU basta; para transcrição sob demanda com SLA de minutos, vale considerar um servidor GPU.
Como instalar Whisper em VPS Ubuntu/Debian passo a passo
O processo de instalação cobre dependências de sistema, ambiente Python isolado e download do modelo escolhido. Comandos testados em Ubuntu 22.04 LTS e Debian 12.
1. Atualizar sistema e instalar dependências base
Conecte via SSH como root ou usuário com sudo:
sudo apt update && sudo apt upgrade -y
sudo apt install -y python3 python3-pip python3-venv ffmpeg git
FFmpeg é essencial: Whisper processa apenas áudio; vídeos passam por extração automática via FFmpeg antes da transcrição. A versão nos repos oficiais (4.4+ no Ubuntu 22.04) é suficiente.
2. Criar ambiente virtual Python e instalar Whisper
Isolar dependências previne conflitos com outros scripts Python no servidor:
mkdir -p ~/whisper-transcribe && cd ~/whisper-transcribe
python3 -m venv venv
source venv/bin/activate
pip install --upgrade pip
pip install openai-whisper
A instalação da biblioteca openai-whisper baixa automaticamente PyTorch com suporte CPU. Para habilitar GPU (CUDA), instale a versão específica do PyTorch antes:
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118
pip install openai-whisper
Valide a instalação:
whisper --help
Deve exibir as opções de linha de comando sem erro.
3. Baixar o modelo escolhido antecipadamente
Na primeira execução, Whisper baixa o modelo automaticamente (~5 GB para large-v3). Para evitar latência na primeira transcrição em produção, faça o download prévio:
whisper --model medium --language pt dummy.mp3 2>/dev/null || true
O comando tenta transcrever um arquivo inexistente, mas força o cache do modelo em ~/.cache/whisper/. Modelos ficam persistentes; downloads subsequentes não ocorrem.
4. Transcrever o primeiro vídeo com saída SRT
Envie um arquivo de vídeo para o servidor via scp, rsync ou diretamente num diretório web. Exemplo com arquivo local palestra.mp4:
whisper palestra.mp4 \
--model medium \
--language pt \
--output_format srt \
--output_dir ./output
Flags principais:
--model:tiny,base,small,medium,large,large-v2,large-v3.--language pt: força português brasileiro; omitir ativa detecção automática (mais lento).--output_format:txt,srt,vtt,json,tsv,all(gera todos os formatos).--output_dir: diretório de destino; padrão é./.
O arquivo palestra.srt aparece em ./output/ após conclusão. Tempo de processamento no modelo medium com CPU EPYC de 4 núcleos: ~15 minutos para 1 hora de vídeo.
5. Processamento em lote de múltiplos arquivos
Whisper aceita múltiplos arquivos numa única chamada:
whisper *.mp4 --model medium --language pt --output_format srt --output_dir ./legendas
Processa todos os .mp4 do diretório sequencialmente. Para paralelização (aproveitar múltiplos cores), use GNU Parallel:
sudo apt install -y parallel
ls *.mp4 | parallel -j 2 "whisper {} --model medium --language pt --output_format srt --output_dir ./legendas"
-j 2 processa dois vídeos simultaneamente. Ajuste conforme vCPUs disponíveis; uma regra prática é vCPUs / 2 para evitar contenção de RAM.
Configuração avançada: integração com n8n para automação
n8n é uma ferramenta de automação self-hosted que orquestra workflows visuais. Integrar Whisper permite transcrição automática de vídeos enviados via webhook, Dropbox, Google Drive ou diretamente por upload.
Workflow típico: webhook → download → transcrição → upload da legenda
- Trigger webhook: n8n expõe endpoint HTTP que recebe URL do vídeo.
- HTTP Request node: baixa o vídeo para
/tmp/na VPS. - Execute Command node: roda
whisper /tmp/video.mp4 --model medium --language pt --output_format srt --output_dir /tmp/. - Read/Write Files node: lê
/tmp/video.srt. - Envio do resultado: node de e-mail, Slack, Google Drive, S3, ou webhook de retorno com a legenda anexada.
Exemplo de comando no Execute Command node:
source /root/whisper-transcribe/venv/bin/activate && \
whisper {{ $json["tmp_video_path"] }} \
--model medium \
--language pt \
--output_format srt \
--output_dir /tmp && \
echo /tmp/$(basename {{ $json["tmp_video_path"] }} .mp4).srt
O workflow retorna o caminho do .srt gerado; o próximo node lê e envia o conteúdo. n8n permite agendar execuções (cron), processar filas do Redis ou monitorar diretórios via inotify.
Escalonamento com filas Redis + workers
Para throughput alto (dezenas de vídeos/hora), substitua chamadas síncronas por fila assíncrona:
- Produtor (n8n ou API): insere job no Redis (URL do vídeo, modelo, idioma, formato).
- Workers (processos Python): consomem jobs da fila, executam Whisper, sobem resultado para storage, marcam job como concluído.
- Escalonamento horizontal: adicione VPS workers conforme demanda; todos conectam ao mesmo Redis central.
Python worker minimalista com rq (Redis Queue):
from rq import Queue
from redis import Redis
import subprocess
redis_conn = Redis(host='redis.seudominio.com')
q = Queue('transcricoes', connection=redis_conn)
def transcrever(video_url, modelo, idioma):
subprocess.run(['wget', '-O', '/tmp/video.mp4', video_url])
subprocess.run([
'whisper', '/tmp/video.mp4',
'--model', modelo,
'--language', idioma,
'--output_format', 'srt',
'--output_dir', '/tmp'
])
# upload da legenda para S3/storage
return '/tmp/video.srt'
# Consumir fila
q.enqueue(transcrever, 'https://exemplo.com/video.mp4', 'medium', 'pt')
Rode múltiplos workers com rq worker transcricoes em terminais ou via systemd. Cada worker pega o próximo job disponível; a fila distribui carga automaticamente.
Formatos de saída e pós-processamento de legendas
Whisper gera cinco formatos principais, cada um com caso de uso específico:
- SRT (SubRip): padrão de legendas para YouTube, Vimeo, players web. Timestamps + texto numerado.
- VTT (WebVTT): formato HTML5 nativo, suporta estilização CSS.
- TXT: transcrição corrida sem timestamps; útil para indexação, busca, resumo por LLM.
- JSON: timestamps granulares por palavra + confiança; ideal para edição programática ou análise.
- TSV: tabela
start\tend\ttext, importável em Excel/LibreOffice para revisão manual.
Ajuste de timestamps e quebras: Whisper tende a gerar segmentos longos (10-30 segundos). Para legendas mais legíveis (máximo 2 linhas, 42 caracteres/linha, conforme guidelines de acessibilidade), pós-processe o SRT com pysrt ou ffsubsync:
import pysrt
subs = pysrt.open('video.srt')
for sub in subs:
if len(sub.text) > 84: # 2 linhas × 42 caracteres
# quebra em frases menores ou ajusta manualmente
pass
subs.save('video_ajustado.srt')
Para sincronização fina (quando áudio e vídeo têm drift), ffsubsync corrige automaticamente comparando o áudio do vídeo com a transcrição existente.
Otimização de performance e consumo de recursos
Alguns ajustes operacionais reduzem tempo de processamento e uso de RAM sem trocar de modelo.
1. Usar formato de precisão reduzida (FP16): Whisper em CPU roda por padrão em FP32. Forçar FP16 economiza RAM e acelera inferência em CPUs modernas:
import whisper
model = whisper.load_model("medium", device="cpu")
model.half() # converte para FP16
Redução típica de 40% no uso de RAM; ganho de velocidade varia (5-15% em EPYC, maior em ARM).
2. Pré-processar vídeo para áudio mono 16 kHz: Whisper espera áudio mono, 16 kHz. Vídeos com múltiplas trilhas ou samplerate alto (48 kHz) adicionam overhead. FFmpeg pode converter antecipadamente:
ffmpeg -i video.mp4 -vn -ar 16000 -ac 1 -c:a pcm_s16le audio.wav
whisper audio.wav --model medium --language pt --output_format srt
Reduz tempo de extração de áudio em ~30% para vídeos 4K com múltiplas trilhas.
3. Ajustar --beam_size e --best_of: Beam search controla quantas hipóteses o modelo mantém. Padrão é beam_size=5. Reduzir para 3 acelera (~20%) com perda mínima de precisão; aumentar para 10 melhora qualidade, mas dobra o tempo.
whisper video.mp4 --model medium --beam_size 3 --language pt
4. Monitorar uso de swap: Transcrições longas com modelo large em VPS de 8 GB podem estourar RAM e usar swap, degradando performance. Configure swap de 4-8 GB e monitore com htop ou dstat. Se swap ativo superar 2 GB consistentemente, upgrade de RAM é necessário.
Comparação de desempenho: modelo × tempo × precisão
Dados coletados numa VPS Pro 30 (8 vCPU AMD EPYC, 16 GB RAM) processando 1 hora de vídeo em português (palestra técnica, áudio limpo):
| Modelo | Tempo (CPU) | Tempo (GPU T4) | WER (pt-BR) | Tamanho (GB) |
|---|---|---|---|---|
| tiny | 3 min | 45 s | ~12% | 0,15 |
| base | 5 min | 1 min | ~9% | 0,29 |
| small | 12 min | 2 min | ~6% | 0,97 |
| medium | 28 min | 5 min | ~4% | 3,1 |
| large-v3 | 65 min | 12 min | ~3% | 6,2 |
WER medido com ferramenta jiwer contra transcrição humana revisada. GPU é Tesla T4 (16 GB VRAM); tempos de CPU em instalação pura sem concorrência.
Conclusão operacional: Para volume alto (>50 horas/dia), medium em CPU múltiplas VPS ou large-v3 em GPU única entregam melhor custo-efetividade. Para prototipagem ou volume baixo (<10 horas/dia), small numa VPS Lite já resolve.
