FFHub vs Transloadit — Comparação para Devs

Comparando FFHub e Transloadit para processamento de mídia na nuvem. Transloadit diferenças em design de API, preço, suporte FFmpeg e curva de aprendizado.

FFHub·2026-05-11

FFHub vs Transloadit — Comparação para Devs

Transloadit e FFHub processam mídia na nuvem, mas as abordagens não poderiam ser mais distintas. Transloadit é uma plataforma completa de processamento de arquivos com sua própria linguagem Assembly e sistema de Robots. FFHub é uma API FFmpeg na nuvem focada: você manda um comando FFmpeg e recebe o resultado. Esta comparação destrincha as diferenças para te ajudar a escolher.

Visão geral rápida

Transloadit é uma plataforma de processamento de mídia construída em torno do conceito de "Assemblies" e "Robots". Você define pipelines em uma DSL baseada em JSON, onde cada passo é tratado por um Robot especializado — um pra codificar vídeo, outro pra redimensionar imagem, outro pra importar arquivo etc.

FFHub é uma API FFmpeg na nuvem. Você manda um comando FFmpeg padrão via REST, o FFHub executa, você recebe o resultado. Um conceito, um endpoint.

Tabela de comparação

Recurso	FFHub	Transloadit
Modelo de API	API REST — manda comando FFmpeg	Assembly DSL com Robots
Escopo de processamento	Vídeo/áudio (FFmpeg)	Vídeo, áudio, imagem, documento
Compatibilidade FFmpeg	100%	Parcial — exposta via parâmetros do Robot
Curva de aprendizado	Sabe FFmpeg = sabe FFHub	Aprende Assembly + catálogo de Robots
Modelo de cobrança	Por segundo de processamento	Por GB de output + planos mensais
Widget de upload	Não	Sim — Uppy (open source)
Fontes de input	URL, upload de arquivo local	URL, S3, GCS, Azure, upload direto
Processamento de imagem	Via FFmpeg (limitado)	Completo (baseado em ImageMagick)
Processamento de documento	Não	Sim (PDF, Office)
Orquestração de pipeline	Comandos FFmpeg sequenciais	Steps Assembly com dependências
Webhook	Sim	Sim (Robot de notify)
Bibliotecas cliente	Node.js, Python, CLI	Node.js, Ruby, Python, PHP, Java, Go
Vendor lock-in	Nenhum — FFmpeg padrão	Alto — Assembly DSL proprietária

Comando FFmpeg vs Assembly DSL

Essa é a diferença fundamental.

FFHub: um comando

curl -X POST https://api.ffhub.io/v1/tasks \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "command": "ffmpeg -i https://example.com/input.mp4 -c:v libx264 -crf 23 -vf scale=1280:720 -c:a aac -b:a 128k output.mp4"
  }'

Se você já mexeu com FFmpeg, lê isso na hora. O comando é o mesmo que você rodaria na sua máquina local.

Transloadit: Assembly com Robots

{
  "steps": {
    "imported": {
      ":robot": "/http/import",
      "url": "https://example.com/input.mp4"
    },
    "encoded": {
      ":robot": "/video/encode",
      "use": "imported",
      "preset": "iphone-high",
      "width": 1280,
      "height": 720,
      "ffmpeg_stack": "v6.0.0",
      "ffmpeg": {
        "crf": 23,
        "b:a": "128k"
      }
    },
    "exported": {
      ":robot": "/s3/store",
      "use": "encoded",
      "bucket": "my-bucket",
      "key": "output/${file.id}.mp4",
      "credentials": "my_aws_creds"
    }
  }
}

A sintaxe Assembly do Transloadit é mais verbosa, mas estruturada. Cada "step" usa um "Robot" que executa uma ação específica. Robots são encadeados via use.

A curva de aprendizado

Com FFHub, a curva é praticamente zero se você já sabe FFmpeg. Você escreve o mesmo comando que rodaria localmente.

Com Transloadit, você precisa aprender:

A estrutura JSON do Assembly
O catálogo de Robots (50+)
Como encadear Robots com use
Parâmetros específicos de cada Robot (que diferem dos flags do FFmpeg)
Sintaxe de templates para Assemblies reutilizáveis

A documentação do Transloadit é extensa, mas é um modelo mental novo pra absorver.

Flexibilidade FFmpeg

FFHub: acesso irrestrito

FFHub roda seu comando FFmpeg como está. Isso significa acesso a tudo que o FFmpeg suporta:

# Filter graph complexo com múltiplos inputs
ffmpeg -i video.mp4 -i overlay.png -i audio.mp3 \
  -filter_complex \
  "[0:v][1:v]overlay=10:10[bg]; \
   [bg]drawtext=text='%{pts\:hms}':fontsize=20:fontcolor=white:x=10:y=H-th-10[v]" \
  -map "[v]" -map 2:a \
  -c:v libx264 -crf 22 -c:a aac output.mp4

# Two-pass encoding pra controle preciso de bitrate
ffmpeg -i input.mp4 -c:v libx264 -b:v 4M -pass 1 -f null /dev/null
ffmpeg -i input.mp4 -c:v libx264 -b:v 4M -pass 2 output.mp4

# GIF animado com paleta otimizada
ffmpeg -i input.mp4 -vf "fps=10,scale=480:-1:flags=lanczos,split[s0][s1];[s0]palettegen[p];[s1][p]paletteuse" output.gif

# Extrair áudio, normalizar e converter pra Opus
ffmpeg -i input.mp4 -vn -af "loudnorm=I=-16:TP=-1.5:LRA=11" -c:a libopus -b:a 128k output.opus

Transloadit: parâmetros do Robot

Transloadit expõe algumas opções do FFmpeg via parâmetros do Robot, mas não todas:

{
  "steps": {
    "encoded": {
      ":robot": "/video/encode",
      "use": "imported",
      "preset": "empty",
      "ffmpeg_stack": "v6.0.0",
      "width": 1280,
      "height": 720,
      "ffmpeg": {
        "crf": 23,
        "b:a": "128k",
        "vf": "drawtext=text='Hello':fontsize=24:fontcolor=white:x=10:y=10"
      }
    }
  }
}

O objeto ffmpeg dentro dos steps deixa passar alguns flags do FFmpeg, mas filter graphs complexos, operações multi-input e várias features avançadas não são suportados diretamente. Você fica limitado ao que o sistema de Robots expõe.

O que não dá pra fazer fácil no Transloadit:

Filter graphs multi-input (combinando várias fontes de vídeo)
Two-pass encoding
Mapeamento arbitrário de stream
Alguns codecs e formatos exóticos
Extração customizada de frames com condições complexas

Cálculo real de custo

Cobrança do FFHub

Simples e transparente:

Por segundo de processamento real
$0.005/segundo (tier padrão)
Armazenamento temporário gratuito por 24 horas
Transferência de dados incluída

Cobrança do Transloadit

Baseada em planos mensais e volume de output:

Plano	Custo Mensal	GB Incluído	Excedente por GB
Startup	$49/mês	10 GB	$4.00/GB
Growth	$149/mês	50 GB	$3.00/GB
Business	$449/mês	200 GB	$2.25/GB
Enterprise	Custom	Custom	Custom

Transloadit cobra pelo tamanho do arquivo de output (GB), não por tempo de processamento. Isso significa:

Um output de 1GB custa o mesmo se levou 10 segundos ou 10 minutos pra processar
Gerar múltiplos outputs a partir de um input multiplica o custo
Outputs só de áudio (arquivos pequenos) saem relativamente baratos
Outputs em alta resolução ou bitrate alto (arquivos grandes) ficam caros

Calculadora: cenários reais

Cenário 1: 1.000 vídeos, 5 min cada, output H.264 720p (~150MB cada)

	FFHub	Transloadit
Conta	30s média × 1.000 × $0.005	150GB output × $3.00/GB (Growth)
Custo de processamento	$150	$450
Plano mensal	$0	$149
Total	$150	$599

Cenário 2: 200 vídeos, 2 min cada, multi-bitrate (1080p + 720p + 480p, ~300MB total por vídeo)

	FFHub	Transloadit
Conta	60s média × 200 × $0.005	60GB output × $4.00/GB (Startup)
Custo de processamento	$60	$240
Plano mensal	$0	$49
Total	$60	$289

Cenário 3: 10.000 extrações de áudio, ~5MB cada output

	FFHub	Transloadit
Conta	3s média × 10.000 × $0.005	50GB output × $3.00/GB (Growth)
Custo de processamento	$150	$150
Plano mensal	$0	$149
Total	$150	$299

A cobrança por segundo do FFHub costuma ser mais previsível e geralmente mais barata, ainda mais quando você gera arquivos de output grandes. O modelo por GB do Transloadit pode ficar mais econômico em tarefas que produzem outputs pequenos a partir de processamento longo. Para uma análise similar, veja a comparação com AWS MediaConvert.

Upload de arquivo: Uppy vs API direta

Transloadit: widget Uppy

Uma das features mais fortes do Transloadit é o Uppy, o widget de upload open source deles:

<script>
  import Uppy from '@uppy/core'
  import Transloadit from '@uppy/transloadit'

  const uppy = new Uppy()
    .use(Transloadit, {
      assemblyOptions: {
        params: {
          auth: { key: 'YOUR_TRANSLOADIT_KEY' },
          steps: {
            encoded: {
              robot: '/video/encode',
              preset: 'iphone-high'
            }
          }
        }
      }
    })
</script>

Uppy entrega drag-and-drop, barra de progresso, upload retomável e captura por webcam direto da caixa. Se você está construindo upload voltado pro usuário final, isso é genuinamente valioso.

FFHub: API e CLI

FFHub trata upload via API e CLI:

# Upload via CLI
ffhub upload video.mp4 --command "ffmpeg -i video.mp4 -c:v libx264 output.mp4"

# Upload via API
curl -X POST https://api.ffhub.io/v1/tasks \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -F "[email protected]" \
  -F 'command=ffmpeg -i video.mp4 -c:v libx264 -crf 23 output.mp4'

FFHub não oferece widget de upload no front. Para uploads de usuário final, você teria que construir o seu ou usar uma solução de terceiro.

Além do vídeo: o escopo do Transloadit

Transloadit processa muito mais que vídeo. O catálogo de Robots inclui:

Imagem: redimensionar, cortar, watermark, detecção de rosto, smart cropping
Documento: gerar PDF, conversão de Office
Áudio: gerar waveform, speech-to-text
Gestão de arquivo: importar/exportar de S3, GCS, Azure, FTP, SFTP

Se sua aplicação precisa de um único serviço para todo processamento de arquivo (não só vídeo), a amplitude do Transloadit é uma vantagem real.

FFHub é laser-focado em FFmpeg. Manda muito bem em vídeo e áudio, mas não trata imagem (além do que FFmpeg consegue) nem documento.

Orquestração de pipeline

Transloadit: Assembly steps

O sistema Assembly do Transloadit deixa você encadear vários Robots numa pipeline:

{
  "steps": {
    "imported": {
      ":robot": "/http/import",
      "url": "https://example.com/input.mp4"
    },
    "thumbnails": {
      ":robot": "/video/thumbs",
      "use": "imported",
      "count": 5
    },
    "encoded_hd": {
      ":robot": "/video/encode",
      "use": "imported",
      "preset": "iphone-high",
      "width": 1920,
      "height": 1080
    },
    "encoded_sd": {
      ":robot": "/video/encode",
      "use": "imported",
      "preset": "iphone",
      "width": 854,
      "height": 480
    },
    "stored": {
      ":robot": "/s3/store",
      "use": ["thumbnails", "encoded_hd", "encoded_sd"],
      "bucket": "my-bucket"
    }
  }
}

Steps que não dependem entre si rodam em paralelo automaticamente. Poderoso para pipelines de mídia complexas.

FFHub: tasks sequenciais ou paralelas

FFHub trata pipelines via múltiplas chamadas de API ou comandos FFmpeg compostos:

# Comando único com múltiplos outputs
ffmpeg -i input.mp4 \
  -vf scale=1920:1080 -c:v libx264 -crf 22 output_hd.mp4 \
  -vf scale=854:480 -c:v libx264 -crf 24 output_sd.mp4 \
  -vf "fps=1/60" -q:v 2 thumb_%02d.jpg

Para pipelines mais complexas, você submete múltiplas tasks e cuida da orquestração no código da sua aplicação. Te dá controle total mas exige mais trabalho de implementação.

Onde o Transloadit ganha

1. Widget Uppy

Para uploads de usuário final, Uppy é excelente — drag-and-drop, upload retomável, webcam, barra de progresso, tudo open source.

2. Processamento amplo de arquivo

Redimensionar imagem, conversão de documento e tarefas não-vídeo num único serviço.

3. Pipelines Assembly

Para workflows multi-step complexos, o sistema Assembly com paralelização automática é poderoso.

4. Bibliotecas cliente

SDKs oficiais em 7+ linguagens com integração profunda com o sistema Assembly.

5. Sistema de templates

Templates Assembly reutilizáveis te deixam definir pipelines uma vez e invocar por nome, deixando deploys mais limpos.

Onde o FFHub ganha

1. FFmpeg-native

Você escreve comandos FFmpeg de verdade. Sem camada de tradução, sem parâmetros de Robot pra decorar. Seu conhecimento FFmpeg se aplica direto.

2. Cobrança mais simples

Por segundo de processamento. Sem planos mensais, sem cálculo por GB, sem surpresa de excedente.

3. FFmpeg completo

Filter graphs complexos, two-pass encoding, codecs arbitrários, mapeamento customizado de stream — tudo que o FFmpeg faz.

4. Curva de aprendizado mais baixa

Se você sabe FFmpeg, começa em minutos. Sem Assembly DSL nem catálogo de Robot pra estudar.

5. Sem vendor lock-in

Comandos FFmpeg padrão rodam em qualquer lugar. Migrar do FFHub é rodar os mesmos comandos no seu próprio servidor.

6. Processamento transparente

Você vê exatamente o que está sendo executado — seu comando FFmpeg. Sem Robot caixa-preta com comportamento não documentado.

Para quem é cada um

Escolha FFHub se:

Precisa de flexibilidade total de comando FFmpeg
Seu processamento é focado em vídeo/áudio
Quer cobrança simples por segundo
Valoriza zero vendor lock-in
Seu time já conhece FFmpeg
Precisa de pipeline de filtros complexo ou opções de codificação

Escolha Transloadit se:

Precisa de widget de upload pra usuário final (Uppy)
Sua aplicação processa imagem e documento além de vídeo
Quer pipelines multi-step gerenciadas via Assembly
Prefere uma abstração de mais alto nível em vez de FFmpeg cru
Precisa da amplitude dos 50+ Robots especializados

Começando com FFHub

Se flexibilidade FFmpeg e simplicidade de preço são o que você precisa, FFHub.io te bota em produção em minutos:

# Instala o CLI
npm install -g ffhub

# Roda qualquer comando FFmpeg na nuvem
ffhub run "ffmpeg -i https://example.com/input.mp4 -c:v libx264 -crf 23 -vf scale=1280:720 output.mp4"

# Faz upload de um arquivo local
ffhub upload video.mp4 --command "ffmpeg -i video.mp4 -c:v libx265 -crf 28 output.mp4"

Sem sintaxe Assembly. Sem catálogo de Robot. Só FFmpeg.

Conclusão

Transloadit e FFHub atendem mercados que se sobrepõem mas são distintos. Transloadit é uma plataforma abrangente de processamento de arquivo — se você precisa de redimensionar imagem, converter documento e codificar vídeo num só lugar com sistema de pipeline sofisticado, é uma escolha forte. FFHub é construído com propósito: dev que quer FFmpeg completo na nuvem, com abstração mínima e preço transparente.

Para vídeo e áudio puro com flexibilidade máxima, a abordagem FFmpeg-native do FFHub é difícil de bater. Para necessidades mais amplas de processamento com orquestração gerenciada, Transloadit oferece mais direto da caixa. Pega a ferramenta que combina com seu caso primário. Se está avaliando FFHub para um produto SaaS ou workflow de transcodificação em batch, esses guias entram fundo em padrões de integração.