Comprimir Vídeo
Mire num tamanho — 10 MB para o Discord, 25 MB para email — ou simplesmente baixe a qualidade. Roda na sua máquina, então não há limite de tamanho nem fila.
O seu navegador lê e recodifica o ficheiro. Nenhum pedido o envia para lado nenhum — esta página não tem servidor para onde o enviar.
Perguntas
Ele consegue atingir um tamanho exato?
É para isso que serve o modo «caber num tamanho». O peso de um arquivo é o seu bitrate multiplicado pela duração, então, sabendo a duração, o bitrate necessário é aritmética pura. Os codificadores não obedecem a um bitrate com precisão — o controle de taxa varia conforme o material —, de modo que, se a primeira passagem erra por mais do que alguns por cento, o erro é medido e o arquivo é recodificado uma vez com o número corrigido. Na prática, fica a poucos por cento do alvo.
Por que 10 MB, 16 MB, 25 MB?
São os muros em que as pessoas realmente batem: 10 MB é o limite gratuito do Discord, 16 MB o do WhatsApp, 25 MB o do Gmail e da maioria dos servidores de email, e 50 MB o do Discord Nitro Basic. A ferramenta mira logo abaixo do limite, e não exatamente nele, porque um arquivo de 10,0 MB ainda é recusado por um limite de 10 MB.
E se o alvo for impossível?
Ele avisa antes de começar e diz qual é o menor tamanho honesto para aquele vídeo. Espremer uma hora de material em 10 MB exigiria um bitrate que nenhuma resolução sobrevive: uma ferramenta que entregasse um arquivo impossível de assistir e chamasse isso de sucesso seria pior do que uma que recusa.
Quanto o meu arquivo vai diminuir?
A estimativa aparece antes de você clicar em qualquer coisa, a partir das opções e da duração. Material direto do celular ou da câmera costuma ser gravado muito acima do necessário, e reduções de 60–90% são rotina. O que já foi comprimido uma vez tem pouco a dar, e a ferramenta compara o seu arquivo com o que a resolução dele razoavelmente exige e avisa quando recodificar só o deixaria maior.
O que realmente deixa um vídeo menor?
Menos pixels e menos bits por pixel. A resolução é a alavanca bruta e confiável: passar de 4K para 1080p elimina três quartos dos pixels antes mesmo de falar em qualidade. O bitrate decide depois quanto detalhe sobrevive. Remover o áudio ajuda pouco: ele raramente passa de alguns por cento de um arquivo de vídeo.
É enviado para algum lugar?
Não. Tudo roda com WebCodecs no seu navegador, e é isso que torna a coisa prática: enviar um gigabyte para um servidor devolver 200 MB é mais lento do que fazer localmente, e ainda deixa o seu material no disco de outra pessoa. Sem limite de tamanho, sem fila e sem marca d'água — porque não há servidor para impô-los.
As outras ferramentas
Integre isto no seu projeto
Compressing video to a target file size — the same way this page does it, on the user's machine, with no server. Take the code, or hand the prompt to a coding agent.
// npm i mediabunny
import { Input, Output, Conversion, BlobSource, BufferTarget, Mp4OutputFormat, ALL_FORMATS } from 'mediabunny';
// Size is bitrate x duration, so a target size fixes the bitrate.
const OVERHEAD = 0.04; // container headers and packaging
const AUDIO_BITRATE = 128_000;
export async function compressToSize(file, targetBytes, { width } = {}) {
const input = new Input({ source: new BlobSource(file), formats: ALL_FORMATS });
const duration = await input.computeDuration();
// Aim under the wall: a file of exactly 10.00 MB is still refused by a 10 MB limit.
const aim = targetBytes * 0.96;
const videoBitrate = Math.max(
90_000,
Math.round((aim * 8 * (1 - OVERHEAD) - AUDIO_BITRATE * duration) / duration),
);
const output = new Output({ format: new Mp4OutputFormat(), target: new BufferTarget() });
const conversion = await Conversion.init({
input,
output,
video: {
...(width ? { width } : {}),
bitrate: videoBitrate,
hardwareAcceleration: 'prefer-hardware', // 180 fps vs 34 on an M5 at 1080p
},
audio: { bitrate: AUDIO_BITRATE },
});
if (!conversion.isValid) throw new Error('Cannot convert this file');
await conversion.execute();
return new Blob([output.target.buffer], { type: 'video/mp4' });
}
// Encoders drift, so measure and correct once if the first pass missed.
const blob = await compressToSize(file, 10 * 1024 * 1024);
console.log(blob.size / 1048576, 'MB'); Build me a video compressor that runs entirely in the browser — no upload, no server.
Requirements:
- Use the "mediabunny" npm package, which wraps WebCodecs. Do not use ffmpeg.wasm: it is ~30 MB and
needs SharedArrayBuffer, which requires COOP/COEP headers that break third-party scripts.
- Let the user target a file size (presets: 10 MB Discord, 16 MB WhatsApp, 25 MB email) as well as
picking a quality.
- To hit a size: size = bitrate x duration, so videoBitrate = (targetBytes * 8 * 0.96 - audioBitrate
* duration) / duration. Aim at 96% of the limit, because a file of exactly 10.00 MB is still
rejected by a 10 MB limit.
- Encoders do not obey a requested bitrate exactly. Measure the result; if it missed by more than 4%
or broke the limit, re-encode once with bitrate * (target / actual), damped to at most a halving
or doubling. Stop at two passes.
- Pass hardwareAcceleration: 'prefer-hardware'. Measured on an M5 at 1080p: 180 fps against 34 fps
for software, and the software encoder also overshot the requested bitrate by 3.5x.
- Show the estimated output size before encoding, and the real before/after afterwards.
- Refuse impossible targets up front: below about 90 kbps video is unwatchable, so if the target
cannot be met at that floor, say so and give the smallest honest size instead of producing junk.
- Warn when the source is already compressed below what its resolution needs — re-encoding it will
make it larger, and only reducing the resolution will help.
Reference implementation: https://life2film.com/tools/video-compressor/
The engine is documented for agents, and every tool page is available as
markdown by adding .md to its address.