# Upload do WordPress excede o limite: qual diretiva PHP mexer

O mapa de sintoma para diretiva, valores de referência por tipo de site e como confirmar o que está realmente em vigor, sem sair mexendo em tudo.

> o limite exibido pelo WordPress é o menor valor entre upload_max_filesize e post_max_size; com memory_limit e max_execution_time, são as quatro diretivas que respondem por quase todos os casos, e em conta cPanel elas vêm da configuração de PHP do domínio, não da cota do plano.

João Rizzon · 2026-09-15 · Painéis

---

O aviso do WordPress ("excede o tamanho máximo de upload para este site") e a barra de progresso que morre em 30% costumam ser tratados como o mesmo problema, e não são. Um é o WordPress calculando um limite antes de tentar; o outro é o PHP jogando a requisição fora no meio do caminho. São diretivas diferentes, e mexer nas quatro de uma vez sem saber qual estava errada é o que faz o mesmo site voltar a quebrar três meses depois.

O caminho eficiente é ler o sintoma, mexer em uma ou duas diretivas, confirmar o valor **em vigor** (que não é necessariamente o que o painel mostra) e registrar o padrão para repetir na carteira inteira.

## Como ir do sintoma para a diretiva certa

Comece por aqui antes de abrir qualquer editor.

| Sintoma observado | Diretiva provável | Por que |
|---|---|---||
| Biblioteca de mídia diz "excede o tamanho máximo de upload para este site" antes de enviar | `upload_max_filesize` ou `post_max_size` | O WordPress calcula o limite exibido como o menor valor entre as duas |
| Barra de progresso vai até o fim e volta com erro genérico ("HTTP error", resposta vazia) | `post_max_size` | Se o corpo do POST passa do limite, o PHP descarta a requisição inteira |
| Upload de arquivo grande em conexão lenta cai sempre no mesmo ponto | `max_input_time` | O tempo conta desde o início do recebimento do corpo da requisição |
| Imagem envia, aparece na biblioteca, mas dá "não foi possível processar a imagem" | `memory_limit` e `max_execution_time` | O redimensionamento acontece depois do upload, em outra requisição |
| Import de WXR para no meio, sem mensagem, página em branco | `max_execution_time` ou `memory_limit` | O import roda em uma requisição longa e é cortado no limite |
| Erro 413 do servidor web, antes de chegar ao PHP | nenhuma diretiva PHP | É limite de corpo de requisição na camada do servidor web |
| "Fatal error: Allowed memory size of X bytes exhausted" | `memory_limit` | A mensagem já traz o valor efetivo em bytes |

Duas leituras desse mapa poupam tempo. A primeira: o limite que o WordPress **mostra** na tela nunca é uma soma nem uma média, é o menor dos dois valores de upload. A segunda: erro que aparece depois que o arquivo já subiu quase nunca é `upload_max_filesize`.

## Por que post_max_size precisa ser maior que upload_max_filesize

`upload_max_filesize` limita o tamanho de **cada arquivo** enviado. `post_max_size` limita o **corpo inteiro** da requisição POST: os arquivos mais os campos de formulário mais a sobrecarga do `multipart/form-data`.

A consequência prática é desagradável: quando o corpo do POST passa de `post_max_size`, o PHP não rejeita apenas o arquivo. Ele descarta `$_POST` e `$_FILES` antes de o código da aplicação rodar. O WordPress recebe uma requisição vazia, não tem o que validar e devolve um erro genérico de AJAX. Nada no painel diz "limite de POST", e o log de erro do PHP costuma registrar apenas um aviso sobre tamanho do POST excedido.

Por isso `post_max_size` fica sempre acima de `upload_max_filesize`. Com os dois no mesmo valor, um arquivo exatamente no limite ainda estoura o POST por causa dos cabeçalhos de cada parte do formulário. Deixar uma folga simples (uns poucos megabytes, ou 2x quando os valores são pequenos) resolve, e em site que aceita upload múltiplo no editor a folga precisa considerar mais de um arquivo por requisição.

### Por que subir só upload_max_filesize não muda o limite exibido

A função do WordPress que gera a frase do limite usa o menor entre os dois valores. Então subir `upload_max_filesize` para 128M e esquecer `post_max_size` em 8M produz uma tela que continua dizendo 8 MB, com o administrador jurando que já mexeu no limite. É o erro mais comum nessa tarefa.

## Import de WXR que para no meio sem mensagem de erro

O import de um XML de exportação (WXR) junta três problemas na mesma requisição: subir o arquivo, parsear o XML e, se a opção de baixar anexos estiver marcada, buscar cada imagem no site de origem. O upload é limitado pelas diretivas de POST. O parse consome memória. O download de anexos consome tempo de parede.

Quando o processo para no meio, com a página em branco ou o HTML cortado, o suspeito é `max_execution_time` ou `memory_limit`. Dá para separar os dois:

- Se o log de erro do PHP traz `Maximum execution time of N seconds exceeded`, é tempo.
- Se traz `Allowed memory size of N bytes exhausted`, é memória, e a mensagem já mostra o limite efetivo em bytes (divida por 1048576 para ter o valor em MB e compare com o que o painel diz).
- Se não traz nada e o processo simplesmente termina, trate como tempo primeiro.

Duas coisas que resolvem sem tocar em diretiva nenhuma, e que costumam ser mais rápidas: quebrar o WXR em arquivos menores por tipo de conteúdo, ou rodar o import por WP-CLI, onde `max_execution_time` do PHP de linha de comando normalmente não é o mesmo do PHP web.

O comando `wp import` depende do plugin WordPress Importer instalado e ativo. Sem ele, o WP-CLI aborta com um erro pedindo a instalação, então instale antes:

```bash
# pré-requisito: sem o plugin, o wp import aborta
wp plugin install wordpress-importer --activate --path=/home/usuario/public_html

# import por CLI, sem depender do limite de POST nem do timeout do navegador
wp import conteudo.xml --authors=create --path=/home/usuario/public_html
```

Se o `wp import` ainda reclamar de plugin ausente, confirme com `wp plugin status wordpress-importer --path=...` (pode estar instalado e inativo, ou instalado em outro caminho). Se o gargalo era o download de anexos, rode o import com `--skip=attachment` e traga os arquivos de `wp-content/uploads` por rsync depois.

### memory_limit tem dois donos, e a constante do WordPress só eleva

Antes de culpar o `wp-config.php`, entenda o que a constante faz. O core aplica `WP_MEMORY_LIMIT` em `wp-includes/default-constants.php` chamando `ini_set()` **apenas quando o valor da constante é maior** que o limite do PHP. Constante menor que o valor do PHP é inerte: ela não reduz nada.

Isso muda o diagnóstico em dois sentidos:

- Se o PHP do domínio está em 128M e o site precisa de 256M, `define( 'WP_MEMORY_LIMIT', '256M' );` no `wp-config.php` resolve sem abrir o painel, desde que o handler permita `ini_set` em `memory_limit` (na prática, permite). Para telas de administração, o core usa `WP_MAX_MEMORY_LIMIT`, que por padrão é 256M e segue a mesma regra de só elevar.
- Se o limite efetivo está **abaixo** do que você configurou no painel, a constante não é a culpada. O suspeito é código chamando `ini_set('memory_limit', ...)` com valor menor em algum plugin ou tema, ou um arquivo `ini` mais específico sobrescrevendo o do painel.

```bash
# procura quem baixa memória por código
grep -rn "ini_set( *['\"]memory_limit" wp-content/ | head
```

## Valores de referência para operação e para migração

Não existe valor certo universal, existe valor coerente com o que o site faz. Os números abaixo são pontos de partida de trabalho, para ajustar depois de medir o caso real, e não um parâmetro da documentação do cPanel.

| Diretiva | Blog e site institucional | Site com vídeo, PDF grande ou tema pesado | Janela de migração/import |
|---|---|---|---||
| `upload_max_filesize` | 32M | 128M | 256M |
| `post_max_size` | 64M | 160M | 320M |
| `memory_limit` | 256M | 384M | 512M |
| `max_execution_time` | 60 | 120 | 300 |
| `max_input_time` | 60 | 120 | 300 |
| `max_input_vars` | 3000 | 5000 | 5000 |

A coluna de migração é temporária. Terminado o import, volte para a coluna de operação normal. Limite alto permanente não é conforto, é uma requisição travada que segura um processo PHP por cinco minutos quando algo dá errado.

`max_input_vars` entra na lista porque ele aparece disfarçado: página de opções de tema ou formulário grande que salva "pela metade", sem erro, quase sempre é o número de campos do POST passando do limite.

## Onde alterar cada diretiva, e o que cada caminho implica

O cPanel documenta a customização dessas diretivas em [How to Customize PHP Directives](https://docs.cpanel.net/knowledge-base/web-services/how-to-customize-php-directives/). Vale ler o artigo antes de escolher o caminho, porque a opção disponível depende do handler PHP em uso na conta. O MultiPHP INI Editor expõe bem mais que as quatro diretivas centrais deste texto: `max_input_time`, `max_input_vars`, `display_errors`, `session.save_path` e outras aparecem na mesma lista.

### MultiPHP INI Editor no modo básico

No cPanel, **Software > MultiPHP INI Editor**, aba de modo básico: escolha o domínio no seletor e edite as diretivas listadas em campos próprios. Resolve a maioria dos casos deste artigo, porque as quatro diretivas relevantes estão entre as listadas. Duas armadilhas: o seletor é por domínio (conta com addon domain precisa do domínio certo selecionado) e o painel gera o arquivo de configuração, ele não garante que outro arquivo mais específico não vai sobrescrever depois.

### MultiPHP INI Editor no modo editor

Mesma ferramenta, aba de editor: você escreve o conteúdo do arquivo `ini` do domínio direto. Use quando precisar de uma diretiva que não aparece no modo básico. Um bloco típico para janela de migração:

```ini
upload_max_filesize = 256M
post_max_size = 320M
memory_limit = 512M
max_execution_time = 300
max_input_time = 300
max_input_vars = 5000
```

### php.ini ou .user.ini, qual arquivo o handler da conta usa

Sem painel, com SSH ou FTP, o arquivo a criar depende do handler PHP da conta:

- **CGI, FastCGI ou suPHP**: crie `php.ini` na raiz da aplicação (normalmente `public_html`, ou o diretório do domínio adicional). As diretivas valem para os scripts daquele diretório.
- **PHP-FPM** (padrão nas contas cPanel atuais): crie `.user.ini` no mesmo lugar. É o mecanismo de INI por diretório do PHP e aceita diretivas de nível `PHP_INI_PERDIR` e `PHP_INI_USER`, o que inclui as quatro deste artigo e também `max_input_vars`.

Para saber qual dos dois usar, veja a linha **Server API** no phpinfo: `FPM/FastCGI` indica `.user.ini`, `CGI/FastCGI` indica `php.ini`, `Apache 2.0 Handler` indica `mod_php`.

Dois cuidados que economizam meia hora de confusão:

- O `.user.ini` é lido com cache controlado por `user_ini.cache_ttl`, cujo padrão é 300 segundos. A mudança pode levar até cinco minutos para aparecer. Espere o TTL e recarregue antes de concluir que não funcionou.
- Diretivas escritas via `php_value` no `.htaccess` só valem com o handler `mod_php`. Em conta que roda PHP-FPM ou CGI, essa linha pode ser ignorada ou derrubar o site com erro 500. Se encontrar `php_value` legado no `.htaccess` de um site, migre para o caminho suportado em vez de empilhar os dois.

Um detalhe operacional: se a conta usa PHP-FPM, mudança de configuração pode exigir reload do pool para valer, e é por isso que o phpinfo às vezes continua mostrando o valor antigo por alguns instantes.

## Como confirmar o valor em vigor, não o que o formulário mostra

O campo preenchido no painel é a intenção. O valor em vigor é o que sobrou depois de todos os arquivos de configuração, do handler e da própria aplicação. Confirme sempre nos dois lugares abaixo, nessa ordem.

### phpinfo mostra de onde vem o valor, comparando Local e Master Value

Crie um arquivo temporário na raiz do site, com nome não adivinhável:

```php
<?php
// salve como info-7a3f.php na raiz do site e APAGUE depois de ler
phpinfo();
```

Abra `https://dominio.com.br/info-7a3f.php` e procure as diretivas. Interessa a coluna **Local Value** (o valor que vale para este site) comparada com **Master Value** (o valor global). Se a Local Value é diferente do que você escreveu, existe outro arquivo mandando. Apague o arquivo assim que terminar, sem exceção: `phpinfo()` exposto entrega caminhos, módulos e variáveis de ambiente para qualquer scanner.

Quem tem SSH resolve sem criar arquivo público:

```bash
wp eval 'echo ini_get("upload_max_filesize"), " ", ini_get("post_max_size"), " ", ini_get("memory_limit"), " ", ini_get("max_execution_time"), PHP_EOL;'
```

Esse comando lê o valor de dentro do WordPress, que é exatamente o contexto que importa.

### Saúde do site, a tela que fecha o assunto com o cliente

No painel do WordPress, **Ferramentas > Saúde do site > Informações > Servidor**: estão listados o tamanho máximo de upload, o limite de memória do PHP, o tamanho máximo de POST e o tempo máximo de execução. É a tela que você manda em print para o cliente, porque é a visão do WordPress e não do servidor.

O valor de memória nessa tela vem de `ini_get('memory_limit')`, ou seja, o limite efetivo naquela requisição. Se ele estiver **maior** que o do painel, a constante `WP_MEMORY_LIMIT` está elevando (comportamento esperado). Se estiver **menor**, alguém chamou `ini_set` com valor mais baixo ou existe outro arquivo `ini` em vigor, e é aí que o `grep` do trecho anterior entra.

Só considere a tarefa concluída depois de um teste real: envie um arquivo próximo do limite novo, não um de 200 KB.

## Padronizar a carteira sem abrir vinte painéis

A parte que economiza tempo de verdade não é consertar um site, é nunca mais ser chamado por isso em nenhum dos outros.

### Defina dois perfis, não vinte valores

Use a tabela de referência como dois perfis fixos: **operação** e **migração**. Guarde os dois blocos `ini` em um arquivo no seu repositório interno. Site novo entra no perfil de operação no dia da instalação, junto com fuso horário e permalinks. Site em migração sobe para o perfil de migração e volta ao normal no fim.

### Audite por CLI em vez de abrir painel por painel

Com SSH de usuário (não root), o laço abaixo varre o home da própria conta e mostra o estado de cada instalação:

```bash
cd ~
for cfg in $(find . -maxdepth 3 -name wp-config.php 2>/dev/null); do
  dir=$(dirname "$cfg")
  printf '%s -> ' "$dir"
  wp --path="$dir" --skip-plugins --skip-themes eval \
    'echo ini_get("upload_max_filesize"), " | ", ini_get("post_max_size"), " | ", ini_get("memory_limit"), " | ", ini_get("max_execution_time"), PHP_EOL;' 2>/dev/null \
    || echo "FALHOU (wp-config existe mas o WP nao carregou: DB, prefixo ou caminho)"
 done
```

O `--skip-plugins --skip-themes` evita que um plugin quebrado atrapalhe a leitura, e o `||` cobre o caso mais comum de falha: `wp-config.php` presente, mas conexão com o banco ou constantes erradas.

Se você tem root e quer varrer `/home/*`, não rode o WP-CLI direto: ele recusa execução como root sem `--allow-root`, e rodar como root pode criar arquivos com o dono errado. Prefira trocar de usuário por instalação:

```bash
# como root: executa a leitura no contexto de cada usuário
for home in /home/*; do
  usuario=$(basename "$home")
  [ -f "$home/public_html/wp-config.php" ] || continue
  printf '%s -> ' "$usuario"
  su -s /bin/bash -l "$usuario" -c "wp --path=$home/public_html --skip-plugins --skip-themes eval 'echo ini_get(\"upload_max_filesize\"), \" | \", ini_get(\"post_max_size\"), \" | \", ini_get(\"memory_limit\"), PHP_EOL;'" 2>/dev/null || echo FALHOU
done
```

Rodar isso a cada trimestre transforma um chamado urgente em manutenção agendada.

### Checklist de fechamento

- Identifiquei o sintoma na tabela antes de mudar qualquer coisa.
- Ajustei `post_max_size` acima de `upload_max_filesize`.
- Comparei o `memory_limit` efetivo com o do painel e, se estava menor, procurei `ini_set` em plugin e tema.
- Confirmei a Local Value no `phpinfo()` e apaguei o arquivo temporário.
- Confirmei os quatro valores em Saúde do site.
- Testei com um arquivo real próximo do limite.
- Voltei o perfil de migração para o de operação, se era o caso.
- Registrei o perfil aplicado na ficha do site.

## O que não resolve, incluindo trocar de plano

Em conta cPanel, subir de plano não move nenhuma das quatro diretivas: `upload_max_filesize`, `post_max_size`, `memory_limit` e `max_execution_time` vêm da configuração de PHP daquele domínio, não da cota de disco nem de banda. A ressalva honesta: existem provedores que definem valores diferentes de memória ou upload no PHP global de cada plano, então confirme na página do plano ou com o suporte antes de afirmar ao cliente que o upgrade não mudaria nada. Se o diagnóstico aponta para uma dessas diretivas e a conta permite editá-las, a correção é de configuração e leva minutos.

Também não resolve: instalar plugin "aumentar limite de upload" que apenas tenta `ini_set()` em diretivas que o PHP não aceita alterar em tempo de execução (`upload_max_filesize` e `post_max_size` estão nessa lista), e continuar enviando a foto original de 4000 pixels de largura. Antes de subir o limite para 256M, pergunte se o arquivo precisa ter aquele tamanho. Imagem redimensionada na origem sobe mais rápido, renderiza mais rápido e não exige memória para o WordPress gerar as versões dela.

E se o erro for 413 do servidor web, com o PHP já configurado corretamente, o limite está na camada anterior ao PHP. Isso é assunto para o suporte da hospedagem, não para o MultiPHP INI Editor.

Para o cliente que perguntou se precisa de um plano maior, uma frase que fecha o assunto sem jargão:

> **** Não é falta de espaço nem de plano: era um limite de configuração do PHP, que já foi ajustado. O arquivo que você tentou enviar passava do tamanho máximo por requisição, o servidor descartava o envio e o painel mostrava um erro genérico. Já testei com um arquivo do mesmo tamanho e está funcionando.

Se o cliente pedir comprovação, o print de **Ferramentas > Saúde do site > Informações > Servidor** com os valores novos encerra a conversa melhor que qualquer explicação.

