Calculadora de tamanho data URI
Saiba o tamanho de um data URI antes de codificar qualquer coisa: um PNG de 1024 bytes vira 1390 caracteres, que ainda cabem no limite padrão de 2048, então a recomendação é incorporar. Grátis no seu navegador.
- Grátis
- Funciona no seu navegador
- Sem cadastro
- Seus dados não saem do seu aparelho
Executar grátis
Exemplo resolvido
- Bytes
- 1.024
- Tipo de mídia
- image/png
- Caracteres do prefixo
- 22
- Caracteres Base64
- 1.368
- Caracteres de preenchimento
- 2
- Caracteres do URI de dados
- 1.390
Equipes que buscam uma calculadora de tamanho de data URI em geral já conhecem o tamanho original do arquivo e precisam do comprimento codificado antes de colar a string em HTML, CSS ou um e-mail. Esta ferramenta aceita o tamanho original em bytes, um tipo MIME opcional para o prefixo RFC 2397 e um orçamento de incorporação opcional.
Como o tamanho de um data URI Base64 é obtido a partir dos bytes originais
Resto um precisa de dois preenchimentos, resto dois precisa de um, e resto zero não precisa de nenhum. O prefixo são os caracteres literais data e dois-pontos, mais o tipo MIME informado, mais ponto-e-vírgula-base64-vírgula. Para image/png esse prefixo tem vinte e dois caracteres; para application/octet-stream, trinta e sete; para image/svg+xml, vinte e seis.
O comprimento total do data URI em caracteres é o do prefixo mais o do Base64. Como o alfabeto Base64 e o prefixo são ASCII, essa contagem de caracteres é igual aos bytes UTF-8 da string. Somar o prefixo sobe a sobrecarga total acima desse piso, e por isso um favicon de vinte e quatro bytes e uma folha de vinte e quatro kilobytes não incham no mesmo percentual.
Esta calculadora aplica essas identidades ao tamanho original em bytes sem ler o arquivo, para que você decida se vale incorporar antes de codificar um único octeto.
Quando incorporar um data URI ainda compensa a sobrecarga de trinta e três por cento
O motivo usual de incorporar é economizar uma requisição: um ícone PNG minúsculo, um subconjunto WOFF2 ou algumas centenas de bytes de CSS crítico podem custar mais em latência e abertura de conexão do que como bytes extras de HTML ou CSS. Um padrão prático são dois kilobytes de data URI: abaixo desse orçamento, incorporar um ícone em um componente ou um modelo de e-mail costuma continuar valendo; acima, sirva o arquivo e deixe o navegador em cache.
HTML de e-mail é um caso especial: muitos clientes bloqueiam imagens remotas até o leitor clicar, então embutir um logotipo como data URI pode justificar um orçamento maior mesmo depois do imposto de trinta e três por cento. Fontes incorporadas em CSS bloqueiam a primeira pintura se a folha for grande, então meça o tamanho codificado antes de colar uma família inteira em uma tag de estilo. Validação falha não consome saldo.
Casos de uso
Orçamentos de incorporação em empacotadores e design systems
Passe ao webpack, ao Vite ou a um pipeline de design system o tamanho de um ícone ou fonte e falhe o build quando o data URI codificado ultrapassar o orçamento combinado.
Logotipos e assinaturas de e-mail HTML
Estime o tamanho de um logotipo embutido depois do Base64 para a mensagem ficar abaixo dos limites do cliente e ainda aparecer sem buscar uma imagem remota.
CSS crítico e folhas de ícones
Compare o tamanho codificado de um SVG pequeno ou de um trecho CSS com um orçamento de incorporação de 2 KiB ou 8 KiB antes de colá-lo no cabeçalho do documento.
Perguntas frequentes
Como calcular o tamanho de um data URI a partir do tamanho original do arquivo?
Envie o tamanho original em bytes (um inteiro positivo).
O tipo MIME altera o tamanho codificado?
Só o prefixo. image/png usa 22 caracteres de prefixo; application/octet-stream usa 37.
Quando incorporar um recurso como data URI?
Sobrescreva budget para alinhar ao limite do empacotador.
Quanto custa a calculadora de tamanho de data URI?
A ferramenta no navegador é gratuita. Nenhum arquivo é enviado nem codificado.
Por que um logotipo em e-mail pode justificar um limite maior?
Porque muitos programas de e-mail bloqueiam imagens remotas até o leitor clicar. Incorporar o logotipo como data URI faz com que ele apareça direto, o que pode compensar mesmo com o acréscimo de cerca de 33 por cento do Base64.
Ferramentas relacionadas
Para desenvolvedores — acesso via API
Tudo nesta página está disponível via API. Esta seção é para equipes que querem integrar a ferramenta aos próprios sistemas; quem não precisa disso pode simplesmente usar a ferramenta acima.
Endpoint
Autenticação por token Bearer. Um único POST coloca a tarefa na fila; o resultado chega por webhook ou link assinado.
Chame do seu código
curl -X POST https://api.kit.forhosting.com/dev/data-uri-size \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"bytes":1024}'const res = await fetch("https://api.kit.forhosting.com/dev/data-uri-size", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"bytes": 1024
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/dev/data-uri-size",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"bytes": 1024
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/dev/data-uri-size", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"bytes":1024}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"bytes":1024}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/dev/data-uri-size", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Exemplo de requisição
{
"bytes": 1024
}Exemplo de resposta
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "dev.data_uri_size",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}A API é assíncrona: cada chamada devolve um task_id na hora. Se preferir polling, consulte o status a até 1 requisição por segundo.
Preço
Preço publicado, sem tokens nem créditos escondidos. Tarefa que falha não é cobrada.
Limites
max_bytes | 1000000000000 |
Erros
| HTTP | Código | O que significa |
|---|---|---|
401 | unauthorized | Token ausente ou inválido. Confira o header Authorization. |
402 | insufficient_balance | Saldo insuficiente para esta tarefa. Faça uma recarga e tente de novo. |
404 | unknown_type | Esse tipo de tarefa não existe. Confira o campo type no catálogo. |
429 | rate_limited | Muitas requisições em pouco tempo. Espere um instante e tente de novo. |
Notas técnicas
Incorporar uma fonte, um ícone ou uma folha de estilos como data URI evita uma requisição HTTP extra, mas a codificação Base64 infla o payload em cerca de um terço e o prefixo data: ainda acrescenta mais caracteres. Devolve o comprimento exato do payload Base64, a contagem total de caracteres do data URI, a sobrecarga do payload perto de trinta e três por cento, a sobrecarga total incluindo o prefixo e uma recomendação para incorporar ou manter um link separado. Chamadas API bem-sucedidas custam US$ 0,002; entrada inválida não é cobrada.
Como o tamanho de um data URI Base64 é obtido a partir dos bytes originais
Um data URI que transporta conteúdo binário usa a forma RFC 2397: data, depois um tipo de mídia opcional, depois o token ponto-e-vírgula-base64, uma vírgula e o payload. O payload é Base64 padrão RFC 4648: cada três bytes originais viram quatro caracteres ASCII, então o comprimento codificado é exatamente quatro vezes o teto do comprimento original dividido por três. Quando o comprimento original não é múltiplo de três, sinais de igual de preenchimento completam o último quarteto para que o payload tenha sempre um múltiplo de quatro. A sobrecarga só do payload fica portanto em cerca de trinta e três por cento — exatamente um terço quando o tamanho original é múltiplo de três, e um pouco mais quando há preenchimento.
Contrato de entrada, forma da resposta e comportamento de erro
Dez mil bytes com o tipo octet-stream padrão geram um URI de 13373 caracteres e recomendação link. Envie por POST um corpo JSON com um campo obrigatório bytes: um inteiro positivo (ou string numérica) com o tamanho original do recurso antes da codificação. Os aliases size, length, n e byte_count mapeiam o mesmo parâmetro, para que scripts de empacotamento e widgets de formulário mantenham os nomes locais. O campo opcional media_type (aliases mime, type, content_type, mime_type) é o tipo MIME escrito no prefixo; se omitido, vale application/octet-stream. O campo opcional budget (aliases max, limit, max_bytes, max_size) é o maior comprimento de data URI que ainda se considera vantajoso incorporar e vale 2048 por padrão, uma regra comum em HTTP/1. Valores ausentes, vazios, não inteiros, zero ou negativos falham com invalid_input nomeando o campo; um tipo de mídia que não seja type/subtype, ou que contenha espaço ou vírgula, é rejeitado do mesmo modo. Essas falhas não são cobradas. Em sucesso o corpo ecoa bytes, media_type e budget; devolve prefix e prefix_chars; devolve base64_chars e padding_chars; devolve data_uri_chars e overhead_chars; devolve overhead_percent do URI completo frente ao arquivo original e payload_overhead_percent só do payload Base64 (a cifra de cerca de trinta e três por cento); devolve expansion_ratio como comprimento do URI sobre os bytes originais; e devolve within_budget mais recommendation igual a inline ou link. Exemplo: 1024 bytes como image/png geram um prefixo de 22 caracteres, 1368 caracteres Base64 com dois preenchimentos, um data URI de 1390 caracteres, sobrecarga de payload cerca de 33.59 por cento e recomendação inline diante do orçamento 2048. Combine os números com o próprio codificador se precisar da string; este endpoint nunca emite o payload codificado.
Quando incorporar um data URI ainda compensa a sobrecarga de trinta e três por cento
Base64 piora essa troca em cerca de um terço, e a multiplexação de HTTP/2 ou HTTP/3 deixa uma requisição à parte mais barata do que era em HTTP/1, então o tamanho de equilíbrio é menor do que muitos posts de 2012 ainda afirmam. Empacotadores que usavam um limite url-loader de oito kilobytes otimizavam sprites de HTTP/1; sobrescreva budget para 8192 se for reproduzir essa regra antiga, ou baixe o valor em sites HTTP/2. Use como portão em uma verificação de pull-request: se data_uri_chars ultrapassar o orçamento, mantenha o recurso como URL.
Perguntas técnicas
Por que a sobrecarga de um data URI Base64 fica em cerca de 33 por cento?
O Base64 padrão codifica 3 bytes como 4 caracteres ASCII, então o payload cresce um terço (exatamente 33.33… por cento quando bytes é múltiplo de 3, um pouco mais com preenchimento). O prefixo data: acrescenta alguns caracteres extras.