HTTP 413 Payload Too Large | Causas e Soluções

Um erro 413 Payload Too Large ocorre quando o tamanho do corpo da requisição excede o máximo permitido pelo servidor. Isso previne que clientes enviem payloads superdimensionados que poderiam sobrecarregar recursos do servidor ou armazenamento. Ele pertence à classe 4xx de erros do cliente na especificação de códigos de status HTTP—o que significa que a correção é sempre do lado do cliente, não do servidor.

O Que Significa 413 Payload Too Large

A Definição HTTP

Per a RFC 9110, 413 indica “o servidor está se recusando a processar uma requisição porque o conteúdo da requisição é maior do que o servidor está disposto ou capaz de processar.”

Características principais:

• Isto é um erro do cliente (classe 4xx)
• O servidor explicitamente recusa a requisição
• O servidor pode fechar a conexão ou sugerir retry com payload menor
• O header Retry-After pode ser incluído

Mudança de Nome Oficial

HTTP/1.1 usava “413 Request Entity Too Large.” HTTP/2 e posteriores usam “413 Payload Too Large” (RFC 9110).

Causas Comuns de Erros 413

1. Limites de Tamanho de Corpo do Servidor Web

Nginx:

# Padrão: 1MB
client_max_body_size 1m;

Apache:

# Padrão: 0 (ilimitado em versões antigas)
LimitRequestBody 10485760

2. Limites de Framework de Aplicação

Node.js (Express):

app.use(express.json({ limit: '1mb' }));
app.use(express.urlencoded({ limit: '1mb', extended: true }));

Django:

DATA_UPLOAD_MAX_MEMORY_SIZE = 2621440  # 2.5 MB

PHP:

post_max_size = 8M
upload_max_filesize = 2M

3. Limites de CDN ou Proxy

CDNs e proxies reversos frequentemente têm seus próprios limites:

• Cloudflare: 100MB para planos gratuitos
• AWS CloudFront: Configurável
• Azure CDN: 100MB padrão
• Azion: Configurável por aplicação via Rules Engine

4. Limites de Load Balancer

Load balancers cloud impõem limites:

• AWS ALB: 100KB para headers, maior para corpo
• Google Cloud Load Balancing: 1MB padrão

5. Regras WAF

Web Application Firewalls podem bloquear payloads grandes:

• Regras ModSecurity
• Políticas WAF cloud
• Regras de segurança customizadas

Troubleshooting de Erros 413

Passo 1: Identifique Onde Está o Limite

Cliente → CDN → Load Balancer → Servidor Web → Aplicação
          ↑           ↑              ↑            ↑
        limite?      limite?        limite?       limite?

Os headers de resposta ajudam a identificar a fonte:

HTTP/1.1 413 Payload Too Large
Server: nginx          # Gerado pelo Nginx
Content-Type: text/html

Passo 2: Verifique Configuração do Servidor Web

Nginx:

grep -r "client_max_body_size" /etc/nginx/

Apache:

grep -r "LimitRequestBody" /etc/apache2/

Passo 3: Verifique Limites da Aplicação

Node.js:

// Verifique configuração de middleware
app.use(express.json({ limit: '10mb' }));

PHP:

php -i | grep -E "(post_max_size|upload_max_filesize)"

Passo 4: Verifique Logs de CDN/WAF

• Cloudflare: Security Events
• AWS WAF: métricas CloudWatch
• ModSecurity: Audit logs
• Azion: Real-Time Events → filtrar por status 413

Passo 5: Teste com Diferentes Tamanhos

# Teste com tamanho de payload específico
dd if=/dev/zero bs=1M count=5 | curl -X POST -H "Content-Type: application/json" --data-binary @- https://example.com/upload

Como Corrigir Erros 413

Aumente Limite do Nginx

http {
    # Limite global
    client_max_body_size 100m;
}

server {
    # Limite por servidor
    client_max_body_size 50m;

    location /api/upload {
        # Limite por localização
        client_max_body_size 500m;
    }
}

Aumente Limite do Apache

<Directory /var/www/html/uploads>
    LimitRequestBody 52428800
</Directory>

Aumente Limites da Aplicação

Express:

app.use(express.json({ limit: '50mb' }));
app.use(express.urlencoded({ limit: '50mb', extended: true }));

NestJS:

app.use(json({ limit: '50mb' }));

Django:

DATA_UPLOAD_MAX_MEMORY_SIZE = 52428800  # 50 MB
FILE_UPLOAD_MAX_MEMORY_SIZE = 52428800

PHP:

post_max_size = 50M
upload_max_filesize = 50M

Configure Limites de CDN

Cloudflare:

• Aumente limites do plano
• Use uploads diretos para origem
• Use Cloudflare R2 ou Workers

AWS CloudFront:

• Use URLs assinadas para uploads grandes
• Faça upload direto para S3

Azion:

• Configure o limite de corpo da requisição via Rules Engine
• Use Edge Storage com URLs presigned para uploads grandes
• Faça upload diretamente para o Azion Edge Storage, contornando limitações de tamanho na camada de proxy

Lidando Corretamente com Uploads Grandes

1. Uploads Fragmentados

Divida arquivos grandes em fragmentos menores:

async function uploadFile(file) {
  const chunkSize = 5 * 1024 * 1024; // Fragmentos de 5MB
  const chunks = Math.ceil(file.size / chunkSize);

  for (let i = 0; i < chunks; i++) {
    const start = i * chunkSize;
    const end = Math.min(start + chunkSize, file.size);
    const chunk = file.slice(start, end);

    await uploadChunk(chunk, i, chunks, file.name);
  }

  await completeUpload(file.name, chunks);
}

2. Uploads Direto para Storage

Faça upload diretamente para armazenamento de objetos:

// Obtenha URL presigned do servidor
const { url, fields } = await fetch('/api/upload-url').then(r => r.json());

// Faça upload direto para S3
const formData = new FormData();
Object.entries(fields).forEach(([key, value]) => formData.append(key, value));
formData.append('file', file);

await fetch(url, { method: 'POST', body: formData });

3. Uploads Streaming

Stream payloads grandes sem carregar na memória:

app.post('/upload', (req, res) => {
  const fileStream = fs.createWriteStream('/uploads/file.dat');

  req.pipe(fileStream)
    .on('error', (err) => res.status(500).send('Upload falhou'))
    .on('finish', () => res.send('Upload completo'));
});

4. Valide Antes do Upload

Verifique tamanho do arquivo client-side antes de upload:

const MAX_SIZE = 50 * 1024 * 1024; // 50MB

document.getElementById('file').addEventListener('change', (e) => {
  const file = e.target.files[0];

  if (file.size > MAX_SIZE) {
    alert(`Arquivo muito grande. Tamanho máximo é ${MAX_SIZE / 1024 / 1024}MB`);
    e.target.value = '';
  }
});

Considerações de Segurança

Prevenção de DoS

Payloads grandes podem ser usados para negação de serviço:

• Defina limites razoáveis baseados em caso de uso
• Limite tempo total de requisição, não apenas tamanho
• Implemente rate limiting por cliente

Limites de Memória

Previna esgotamento de memória:

// Use streaming para uploads grandes
app.use(express.raw({
  limit: '50mb',
  type: 'application/octet-stream'
}));

Validação de Entrada

Sempre valide conteúdo uploadado:

const ALLOWED_TYPES = ['image/jpeg', 'image/png', 'application/pdf'];

app.post('/upload', (req, res) => {
  if (!ALLOWED_TYPES.includes(req.file.mimetype)) {
    return res.status(415).send('Tipo de mídia não suportado');
  }

  // Escaneie por vírus, valide estrutura, etc.
});

Tratamento de Erro do Lado do Cliente

Lide com 413 graciosamente no seu cliente:

async function uploadFile(file) {
  try {
    const response = await fetch('/api/upload', {
      method: 'POST',
      body: formData
    });

    if (response.status === 413) {
      const max = response.headers.get('X-Max-Size');
      throw new Error(`Arquivo muito grande. Tamanho máximo é ${max} bytes`);
    }

    if (!response.ok) throw new Error('Upload falhou');

    return response.json();
  } catch (error) {
    console.error('Erro de upload:', error);
    throw error;
  }
}

Perguntas Frequentes

Qual o limite padrão do Nginx? 1MB (client_max_body_size 1m).

Qual o limite padrão do Apache? Varia por versão. Versões modernas frequentemente não têm limite por padrão.

Como lido com uploads de arquivos muito grandes? Use uploads fragmentados, URLs presigned para storage cloud ou uploads streaming.

Posso retornar o tamanho máximo na resposta de erro? Sim, adicione um header customizado: X-Max-Body-Size: 10485760.

Devo permitir uploads ilimitados? Não. Sempre defina limites para prevenir ataques DoS e esgotamento de recursos.

Como testo limites de upload? Use dd para criar arquivos de teste de tamanhos específicos, depois faça upload com curl.