# Erro 413 no upload: o limite não é do PHP

Como separar o limite do servidor web do limite do PHP, corrigir o certo em uma tentativa e deixar o ajuste padronizado em toda a carteira de sites.

> o erro 413 vem do servidor web (LiteSpeed/Apache) ou de um CDN/proxy à frente dele, nunca do PHP: a requisição é cortada antes de o interpretador rodar, então mexer em upload_max_filesize não adianta. Corrija elevando LimitRequestBody no .htaccess ou o limite de corpo do vhost, e alinhe com post_max_size.

João Rizzon · 2026-10-14 · Infraestrutura web

---

## O 413 é do servidor web e o PHP nem chega a rodar

Quando um upload estoura o limite do PHP, o WordPress devolve uma tela dele mesmo: "O arquivo enviado excede a diretiva upload_max_filesize no php.ini". É uma página HTML, com status 200, dentro do admin.

Quando o estouro é do servidor web, o PHP nem roda. O LiteSpeed (ou o Apache) corta a requisição enquanto o corpo ainda está subindo e responde **413 Request Entity Too Large**. A página é crua, sem CSS do WordPress, às vezes só uma linha de texto. É esse o sinal.

Por isso a cena clássica: o dev sobe `upload_max_filesize` e `post_max_size` para 256M no painel, confere com `phpinfo()`, vê os valores novos aplicados, tenta de novo e toma o mesmo erro. Nada do que ele mexeu está no caminho da requisição que falhou.

### Tabela de diagnóstico rápido por mensagem e status

| O que aparece na tela | Status HTTP | Camada que barrou | Onde mexer |
|---|---|---|---||
| "excede a diretiva upload_max_filesize" | 200 | PHP | `upload_max_filesize` |
| "413 Request Entity Too Large" | 413 | Servidor web (LiteSpeed/Apache) | `LimitRequestBody` ou config do vhost |
| Barra trava em 100% e dá erro genérico / HTTP error | 500 ou 504 | PHP (tempo/memória) ou proxy | `max_execution_time`, `memory_limit` |
| Upload só falha em arquivos grandes no editor de mídia | 200 com JSON de erro | PHP | `post_max_size` |

### Confirmando o status HTTP pelo terminal

Não confie na aparência da página. Pegue o número:

```bash
# gera um arquivo de teste de 60 MB (exemplo)
head -c 60M /dev/urandom > teste-60mb.bin

# envia e mostra só os cabeçalhos da resposta
curl -s -o /dev/null -D - \
  -F "file=@teste-60mb.bin" \
  https://site-do-cliente.com.br/wp-admin/async-upload.php
```

Se a primeira linha vier `HTTP/2 413`, está decidido: é limite de corpo de requisição do servidor web. Rodar o mesmo comando com um arquivo de 5 MB deve dar outra resposta: sem cookie de sessão e sem nonce, o normal é um 302 para a tela de login, às vezes 403. Em qualquer um desses casos a requisição chegou ao PHP.

## Por que o limite não aparece na tela de PHP do painel

A seleção de versão de PHP, o editor de `php.ini` e o botão de "limites de upload" do painel configuram o interpretador. O teto de corpo da requisição é do processo que recebe a conexão TCP, lê os cabeçalhos e decide se continua lendo o corpo. Ele é avaliado antes de qualquer handler ser acionado.

A documentação do LiteSpeed sobre otimização de tamanho de upload trata os dois eixos como coisas separadas e pede que ambos sejam ajustados: o limite do servidor e as diretivas de PHP ([LiteSpeed Cloud: Optimize Upload Size](https://docs.litespeedtech.com/shared/cloud/OPT-UPLOAD/)). Mexer só em um lado deixa o menor valor mandando.

E há um detalhe que confunde ainda mais o diagnóstico: como o corte acontece durante a leitura do corpo, o log de erro do PHP fica limpo. Nenhuma linha. O registro do 413 está no log de acesso do servidor web, não no `error_log` do site.

## Subindo o limite com LimitRequestBody no .htaccess

O caminho mais rápido em hospedagem compartilhada com LiteSpeed é a diretiva `LimitRequestBody`, herdada do Apache e interpretada pelo LiteSpeed no `.htaccess`. O valor vai em **bytes**.

```apache
# .htaccess na raiz do site
# 256 MB = 256 * 1024 * 1024
LimitRequestBody 268435456
```

Coloque fora dos blocos `# BEGIN WordPress` / `# END WordPress`, senão o WordPress pode sobrescrever ao regravar as regras de permalink.

Valores úteis para copiar:

| Limite desejado | Bytes |
|---|---||
| 32 MB | 33554432 |
| 64 MB | 67108864 |
| 128 MB | 134217728 |
| 256 MB | 268435456 |
| 512 MB | 536870912 |

No Apache, `LimitRequestBody 0` significa sem limite. Evite usar isso em site de cliente: um endpoint de upload aberto sem teto é convite para encher o disco. Defina um número e documente qual é.

### O que fazer quando o .htaccess não eleva o limite

Em algumas configurações o limite de corpo é fixado no nível do servidor ou do virtual host e o `.htaccess` não consegue elevá-lo, só reduzi-lo. Sintoma: você gravou `LimitRequestBody 268435456`, limpou cache, e o 413 continua exatamente no mesmo tamanho de arquivo.

Nesse caso o ajuste é na configuração do vhost (no WebAdmin do LiteSpeed, em `Max Request Body Size` do listener/vhost, ou no bloco do vhost no Apache), e em hospedagem compartilhada isso é pedido ao suporte. É um pedido de uma linha: "preciso que o limite de corpo de requisição do vhost do domínio X seja elevado para N MB". Não peça "aumentar o upload", porque isso costuma ser respondido com as diretivas de PHP que você já ajustou.

## Alinhando LimitRequestBody, post_max_size e upload_max_filesize

Três tetos precisam estar coerentes, e o menor deles é o que vale na prática:

- `LimitRequestBody` (servidor web): corpo inteiro da requisição.
- `post_max_size` (PHP): corpo inteiro do POST, incluindo campos de formulário.
- `upload_max_filesize` (PHP): cada arquivo individual.

A regra prática é deixar `LimitRequestBody` >= `post_max_size` > `upload_max_filesize`, com folga entre eles. A folga existe porque o corpo multipart carrega mais do que o arquivo: delimitadores, nomes de campo, nonce, e eventualmente vários arquivos na mesma requisição.

```ini
; php.ini / configuração de PHP do painel
upload_max_filesize = 128M
post_max_size = 192M
memory_limit = 256M
max_execution_time = 300
```

Com esse conjunto, `LimitRequestBody` em 256 MB (268435456) deixa espaço suficiente. Depois de aplicar, confirme pelo WordPress em **Ferramentas > Saúde do site > Informações > Servidor**, que mostra os valores de PHP efetivamente em uso. Se o painel aplicou por pool e o site usa outro, a diferença aparece aqui.

Vale lembrar que `max_execution_time` e `memory_limit` não causam 413. Eles causam 500, 504 ou tela branca depois que o arquivo já subiu. Se você está caçando um 413, não perca tempo neles.

## Confirmando que resolveu antes de fechar o chamado

Não feche o chamado com "deve estar funcionando". Repita exatamente o upload que falhou, com o mesmo arquivo, no mesmo lugar do painel.

### Limpe o cache antes de testar

Em LiteSpeed, purgue tudo pelo LSCache antes do teste. Um `.htaccess` novo exige que a requisição seja realmente processada, e página de admin cacheada pode mascarar o resultado.

### Teste pelo curl com o tamanho exato do arquivo

```bash
curl -s -o /dev/null -w "%{http_code}\n" \
  -F "file=@teste-60mb.bin" \
  https://site-do-cliente.com.br/wp-admin/async-upload.php
```

Qualquer resposta que não seja `413` significa que a requisição passou do teto do servidor web e chegou ao PHP, ou seja, o limite agora comporta o arquivo. Tipicamente vem `302` para a tela de login, às vezes `403`, porque falta cookie de sessão e nonce. Os dois são bom sinal.

### Teste pela interface real, não só pelo curl

Upload pela biblioteca de mídia e, se for o caso, pelo instalador de plugin/tema (`.zip` grande costuma ser o gatilho real do chamado). Uploads por formulário de plugin, como Gravity Forms ou WooCommerce, passam por outra rota e merecem um teste próprio.

### Registre o valor aplicado e a data

Anote no seu controle interno do site: limite do servidor, `post_max_size`, `upload_max_filesize` e a data. Seis meses depois, quando alguém reclamar de novo, você não vai refazer o diagnóstico do zero.

## Checklist para padronizar o limite em vários sites

Se você mantém uma carteira de sites, trate isso como baseline e não como incidente:

- Defina um padrão único da agência. Por exemplo: servidor 256 MB, `post_max_size` 192M, `upload_max_filesize` 128M. Um número só, para todos.
- Mantenha um trecho de `.htaccess` versionado com `LimitRequestBody` e cole fora dos marcadores do WordPress em cada site novo.
- Inclua a verificação no checklist de onboarding: subir um arquivo de teste do tamanho do padrão antes de entregar o site.
- Para sites com upload pesado (fotógrafo, área de membros com vídeo, loja com PDF grande), revise o número caso a caso e documente a exceção.
- Se o site usa CDN ou proxy na frente, confirme o limite de corpo também lá. Um proxy pode devolver 413 antes de a requisição chegar à hospedagem, e aí nada do que você fez no `.htaccess` importa.
- Com WP-CLI, dá para fazer uma triagem rápida em lote: `wp eval 'echo ini_get("post_max_size");'` rodado por site no seu script de manutenção. Só não feche diagnóstico por ele: o WP-CLI roda sob o PHP de linha de comando, que normalmente carrega um `php.ini` diferente do LSPHP/PHP-FPM que atende o site. Use a saída para achar os sites fora do padrão e confirme o valor real em Ferramentas > Saúde do site > Informações > Servidor, ou por um `phpinfo()` servido pelo próprio site.

## A frase pronta para explicar ao cliente

O cliente final não quer saber de camada. Ele quer entender por que "mexeram em tudo e não resolveu". Use algo assim:

> **** "O site tem dois limites de tamanho de arquivo: um do programa que roda o WordPress e outro do servidor que recebe o arquivo pela internet. Ajustamos o primeiro e o segundo continuou cortando o envio antes de chegar no site. Por isso o erro parecia o mesmo. Agora os dois estão alinhados e o arquivo de X MB sobe normalmente."

Funciona porque explica a causa sem jargão, justifica a tentativa anterior sem parecer erro, e termina com uma verificação concreta. Se precisar de uma versão ainda mais curta para WhatsApp: "Existiam dois limites diferentes. O primeiro ajuste pegou só um deles. Resolvido, pode subir o arquivo."

E uma recomendação contra o nosso próprio interesse: 413 raramente é motivo para trocar de plano. É configuração, não recurso. Se alguém sugerir upgrade para resolver um 413, peça primeiro o status HTTP exato e o valor atual do limite de corpo da requisição.

