# Script PHP roda no navegador mas falha no cron do cPanel

Como descobrir o caminho do binário que o seu domínio usa, provar que ele tem as extensões certas e trocar o comando antes de salvar o agendamento.

> a primeira hipótese a testar é que o cron está chamando outro binário de PHP, e não o que serve o site. A correção é usar o caminho absoluto da versão do domínio (exemplo: /opt/cpanel/ea-php82/root/usr/bin/php) e conferir antes com php -v e php -m.

João Rizzon · 2026-10-01 · Painéis

---

## O mesmo servidor tem mais de um PHP instalado

Quando você abre `https://seusite.com.br/tarefa.php` no navegador, quem executa o arquivo é o PHP do site: a versão escolhida para aquele domínio, com as extensões ativadas para aquele domínio e lendo o `php.ini` daquela versão no modo web.

Quando o cron dispara, nada disso está garantido. O cron executa um programa a partir de uma linha de comando, e essa linha pode acabar chamando outro binário de PHP, de outra versão, com outro conjunto de extensões e outro arquivo de configuração.

A [documentação do cPanel sobre PHP](https://docs.cpanel.net/knowledge-base/general-systems-administration/cpanel-php/) descreve uma dessas instalações: o PHP interno do painel, em `/usr/local/cpanel/3rdparty/bin/php`, que existe para o cPanel & WHM funcionar e não para servir sites ou rodar aplicações do usuário. É uma instalação separada das versões do EasyApache que atendem os domínios.

Resultado prático: se o comando do cron for simplesmente `php /home/usuario/public_html/tarefa.php`, você não controla qual PHP vai responder. Dependendo do `PATH` do ambiente do cron, pode ser uma versão antiga, pode ser o PHP interno do painel, pode ser nenhum. O script abre no navegador e morre no agendamento, com erro de função indefinida, erro de classe não encontrada, ou silêncio total.

A correção é sempre a mesma ideia: descobrir o caminho absoluto do binário da versão que o site usa, provar que aquele caminho tem as extensões necessárias e colocar esse caminho no comando do cron.

## Descobrir qual versão de PHP o domínio usa

### Onde o MultiPHP Manager mostra a versão do domínio

- Entre no cPanel.
- Na busca do topo, digite **MultiPHP**.
- Abra **MultiPHP Manager** (seção Software).
- Na lista de domínios, olhe a coluna **PHP Version** do domínio em questão.

O valor costuma aparecer como `ea-php82`, `ea-php83`, `alt-php81`, ou como "inherited" (herdado da configuração padrão da conta). Se estiver herdado, o valor efetivo é o que está definido no topo da tela ou no padrão do servidor.

Anote exatamente o que aparece. O sufixo numérico é o que vai montar o caminho do binário no passo seguinte.

### Confirmando a versão pelo phpinfo no navegador

Se quiser a confirmação que vem do próprio site, crie um arquivo temporário na pasta do domínio com este conteúdo:

```php
<?php
phpinfo();
```

Abra pelo navegador, confira a linha **PHP Version** no topo e a linha **Loaded Configuration File**. Depois **apague o arquivo**: `phpinfo()` exposto publicamente entrega caminhos, módulos e configurações do servidor para qualquer um.

Guarde esses dois valores em um bloco de notas. Eles vão ser comparados com o que a linha de comando mostra.

## Achar o caminho absoluto do binário de PHP

Num servidor cPanel padrão, os binários ficam em caminhos previsíveis conforme a origem da instalação de PHP. A tabela abaixo lista os formatos de caminho como **exemplos de servidor cPanel padrão**, usando a versão 8.2 só para ilustrar. Troque o número pela versão do seu domínio e confirme a existência do arquivo antes de usar.

| Origem do PHP | Exemplo de caminho do binário | Para que serve |
|---|---|---||
| EasyApache 4 (ea-php) | `/opt/cpanel/ea-php82/root/usr/bin/php` | É o PHP que serve os sites na maioria dos servidores cPanel |
| CloudLinux alt-php | `/opt/alt/php82/usr/bin/php` | Servidores com CloudLinux e PHP Selector |
| LiteSpeed (lsphp) | `/usr/local/lsws/lsphp82/bin/lsphp` | Binário que o LiteSpeed usa para servir o site; não é a linha de comando |
| PHP interno do painel | `/usr/local/cpanel/3rdparty/bin/php` | Uso do cPanel & WHM, não dos sites |
| Link genérico | `/usr/local/bin/php` ou `/usr/bin/php` | Aponta para alguma das opções acima, ou para nada |

O último caso é a armadilha. `php` sem caminho vai cair em algo dessa linha, e o que está do outro lado do link pode não ser o PHP do seu site.

O `lsphp` merece um parágrafo à parte. Num cPanel com LiteSpeed, quem executa o PHP do site é esse binário, e é por ele que o navegador passa. Só que ele é a SAPI do servidor web, não a de linha de comando: no cron você continua chamando o CLI do `ea-php` (ou do `alt-php`) da mesma versão do domínio. As duas instalações compartilham a versão e, normalmente, o conjunto de extensões, mas quem vai no comando agendado é o caminho do `ea-php`.

### Listar as versões de PHP instaladas no servidor

Abra o **Terminal** do cPanel (busque por "Terminal" no painel) ou conecte por SSH e rode:

```bash
ls -d /opt/cpanel/ea-php*
```

A saída esperada é uma lista de diretórios, um por versão instalada pelo EasyApache, algo como `/opt/cpanel/ea-php74  /opt/cpanel/ea-php82  /opt/cpanel/ea-php83`.

Se o servidor usar CloudLinux, o equivalente é:

```bash
ls -d /opt/alt/php*
```

Confirme que o binário existe de fato no caminho que você montou:

```bash
ls -l /opt/cpanel/ea-php82/root/usr/bin/php
```

Se a resposta for `No such file or directory`, o caminho está errado ou a versão não está instalada. Volte ao `ls -d` e use um dos diretórios listados.

### Para onde aponta o `php` chamado sem caminho

```bash
which php
```

Esse comando mostra qual binário o seu shell resolveria ao digitar `php`. Vale como diagnóstico, não como solução: o ambiente do cron tem um `PATH` próprio, normalmente mais curto que o do seu login por SSH, então o `php` do cron pode não ser o mesmo `php` que o `which` mostrou. É exatamente por isso que o comando agendado precisa de caminho absoluto.

## Conferir versão e extensões naquele caminho

Agora a parte que evita o segundo erro. Não basta ter o caminho: é preciso provar que aquele binário tem o que o script precisa.

### Rodar `php -v` e olhar a SAPI entre parênteses

```bash
/opt/cpanel/ea-php82/root/usr/bin/php -v
```

Saída esperada: três ou quatro linhas começando por `PHP 8.2.x (cli)`, seguidas de copyright e Zend Engine. Dois detalhes para olhar:

- O número tem que bater com o que o MultiPHP Manager mostrou para o domínio.
- O que vem entre parênteses é a SAPI. No binário do `ea-php` ou do `alt-php`, tem que aparecer `(cli)`, que é a mesma interface que o cron vai usar. Se a saída trouxer `(litespeed)` ou `(cgi-fcgi)`, você rodou o `-v` no binário que serve o site (o `lsphp`, por exemplo), e não no que vai no comando agendado.

Para ver a diferença de perto, rode também:

```bash
/usr/local/cpanel/3rdparty/bin/php -v
```

Se o número for diferente do anterior, você acabou de ver o motivo da falha com os próprios olhos.

### Rodar `php -m` e procurar cada extensão do script

```bash
/opt/cpanel/ea-php82/root/usr/bin/php -m
```

A saída é uma lista de módulos, um por linha, em ordem alfabética, sob o cabeçalho `[PHP Modules]`. É essa lista que importa, não a do `phpinfo()` do navegador.

Para checar uma extensão específica sem ler a lista inteira:

```bash
/opt/cpanel/ea-php82/root/usr/bin/php -m | grep -i curl
```

Saída esperada: a linha `curl`. Se não vier nada, a extensão não está carregada nesse binário, e qualquer `curl_init()` no script vai estourar `Call to undefined function` quando o cron rodar, mesmo que funcione no navegador.

Repita o `grep` para cada extensão que o script usa de verdade: `mysqli`, `pdo_mysql`, `mbstring`, `json`, `openssl`, `zip`, `gd`, `intl`, `imagick`, o que for o caso.

## Por que a extensão aparece no navegador e some na linha de comando

Essa é a parte que derruba quem já acertou o caminho do binário.

A mesma versão de PHP pode carregar configurações diferentes conforme a interface. O modo web (PHP-FPM, CGI, suPHP, LSAPI) e a linha de comando leem o arquivo de configuração da instalação, mas o modo web ainda recebe camadas extras que a CLI não recebe, como os arquivos `.user.ini` ou `php.ini` colocados na pasta do site e as diretivas por domínio ajustadas no **MultiPHP INI Editor**.

Para ver qual arquivo o binário está lendo na linha de comando:

```bash
/opt/cpanel/ea-php82/root/usr/bin/php --ini
```

A saída traz três informações úteis:

- `Configuration File (php.ini) Path`: o diretório onde o PHP procura o arquivo.
- `Loaded Configuration File`: o `php.ini` que ele efetivamente carregou.
- `Scan for additional .ini files in` e `Additional .ini files parsed`: o diretório `php.d` e os arquivos de extensão que foram lidos.

Compare o `Loaded Configuration File` dessa saída com o `Loaded Configuration File` que você anotou do `phpinfo()` no navegador. Quando os dois são diferentes, está explicada a extensão que existe num lado e não existe no outro. E o `.user.ini` que você colocou na pasta do site não aparece aqui, porque a CLI não lê esse arquivo.

Consequências práticas:

- `memory_limit`, `max_execution_time` e `upload_max_filesize` definidos por domínio não valem para o cron. Na CLI, `max_execution_time` tem comportamento próprio e o limite de memória é o do `php.ini` da instalação.
- O modo básico do MultiPHP INI Editor mexe em diretivas (`memory_limit`, `max_execution_time`, `upload_max_filesize` e afins), não em extensões. Não procure ali a chave para ligar uma extensão: ela não existe nessa tela. Extensão se ativa em **Select PHP Version** (servidores com CloudLinux) ou no EasyApache, pelo WHM, e aí vale para a instalação inteira, incluindo a linha de comando.
- Ajustar `error_reporting` no site não muda o que o cron vai registrar.

Se faltar extensão na CLI, o caminho é ativar a extensão na instalação de PHP (pelo **Select PHP Version** / **PHP Extensions** do cPanel, quando disponível, ou pedindo ao administrador do servidor no EasyApache), não por arquivo na pasta do site. Depois reconfira com `php -m` no caminho absoluto. Enquanto o `-m` não mostrar a extensão, o cron vai continuar falhando.

## Montar e salvar o comando do cron

### Anote o comando antigo antes de editar

O campo de comando do cron no cPanel não tem histórico. Se você sobrescrever e o novo comando estiver errado, você perde o antigo.

- Entre no cPanel, busque por **Cron Jobs** e abra a página.
- Em **Current Cron Jobs**, localize a linha da tarefa.
- Clique em **Edit**.
- Selecione todo o conteúdo do campo de comando, copie e cole num arquivo de texto no seu computador, junto com os cinco campos de horário.

Só depois disso edite. Se algo der errado, você cola o comando antigo de volta e volta ao estado anterior.

### Caminho absoluto do binário, do script e registro de saída

O formato mínimo que resolve o problema deste artigo:

```bash
/opt/cpanel/ea-php82/root/usr/bin/php /home/usuario/public_html/tarefa.php
```

Linha a linha: o primeiro item é o caminho absoluto do binário que você validou com `-v` e `-m`; o segundo é o caminho absoluto do script. Nenhum dos dois pode ser relativo, porque o diretório de trabalho do cron não é a pasta do site.

Versão recomendada, com registro de saída:

```bash
/opt/cpanel/ea-php82/root/usr/bin/php /home/usuario/public_html/tarefa.php >> /home/usuario/logs/tarefa.log 2>&1
```

- `>>` acrescenta a saída normal ao final do arquivo de log, sem apagar o que já estava lá.
- `2>&1` manda também a saída de erro para o mesmo arquivo. Sem isso, os avisos e erros fatais vão para o e-mail do cron, ou para lugar nenhum.

Crie a pasta antes, senão o redirecionamento falha:

```bash
mkdir -p /home/usuario/logs
```

Troque `usuario` pelo nome de usuário da sua conta cPanel em todos os caminhos. Ele aparece no canto direito do painel, na lista de informações gerais.

### Teste o comando no Terminal antes de agendar

Cole exatamente a mesma linha no Terminal do cPanel e execute. Se o script funcionar ali, funciona no cron, com uma ressalva: variáveis de ambiente e `PATH` ainda podem diferir. Se o script chama outros programas por nome (`mysqldump`, `wget`, `convert`), use também o caminho absoluto deles.

Depois de rodar, leia o log:

```bash
tail -n 30 /home/usuario/logs/tarefa.log
```

### O sinal de porcentagem quebra a linha do cron

Dentro de um comando de cron, o caractere `%` não é literal: ele é interpretado como quebra de linha e o que vem depois vira entrada do comando. Se o seu comando tiver uma data como `date +%Y-%m-%d` no nome do arquivo de log, escape cada um deles com barra invertida: `date +\%Y-\%m-\%d`. É a causa clássica de um comando que funciona colado no Terminal e se comporta de forma estranha quando agendado.

## Quando chamar pela URL é a escolha certa

Trocar o binário resolve o problema quando a causa é o PHP errado, mas há casos em que ela não é. Se o script depende do contexto web, por exemplo lê `$_SERVER['HTTP_HOST']`, usa sessão, depende de regra de `.htaccess`, ou é um arquivo de uma aplicação que espera ter sido chamado pelo servidor web, rodar na CLI muda o comportamento mesmo com a versão e as extensões certas.

Nesse caso, agende uma requisição HTTP em vez da execução direta:

```bash
/usr/bin/curl -s https://seusite.com.br/tarefa.php > /dev/null 2>&1
```

Assim quem executa o PHP é o mesmo handler que atende o navegador, com o mesmo `php.ini` e as mesmas extensões do site. É a forma mais usada para disparar o `wp-cron.php` do WordPress por agendamento externo.

Contras honestos dessa abordagem: o script passa a ficar sujeito ao tempo máximo de execução do servidor web e a quem mais conseguir abrir aquela URL. Se a tarefa é longa ou sensível, proteja o endpoint com um token na query string e prefira a execução pelo binário.

## Sintomas do cron e a causa provável de cada um

| O que o cron devolve | Causa provável | Onde verificar |
|---|---|---||
| Nenhum e-mail, nenhum efeito | Comando sem caminho absoluto e `php` não resolvido no `PATH` do cron | Rodar `which php` e trocar pelo caminho completo |
| `/bin/sh: php: command not found` | Mesmo caso acima, com a mensagem explícita | Caminho absoluto do binário |
| `No such file or directory` | Caminho do script errado ou relativo | `ls -l` no caminho do `.php` |
| `Call to undefined function` | Extensão ausente na CLI | `php -m` no caminho absoluto |
| `Parse error` ou `syntax error` só no cron | Binário de versão diferente da do site | `php -v` no caminho absoluto e comparar com o MultiPHP Manager |
| Script roda mas se comporta diferente | `php.ini` da CLI diferente do `php.ini` do site | `php --ini` e comparar com o `phpinfo()` |
| Erro de permissão em arquivo gravado | Execução sob outro contexto, dono e permissão da pasta | `ls -l` na pasta de destino |
| Saída estranha com data no nome do log | `%` sem escape na linha do cron | Substituir por `\%` |

## Checklist antes de salvar o cron

- Versão do domínio anotada no **MultiPHP Manager**.
- Caminho do binário confirmado com `ls -l`.
- `php -v` naquele caminho batendo com a versão do domínio e mostrando `(cli)`. Se vier `(litespeed)` ou `(cgi-fcgi)`, é o binário do servidor web, troque pelo do `ea-php`/`alt-php`.
- `php -m` naquele caminho listando todas as extensões que o script usa.
- `php --ini` comparado com o `Loaded Configuration File` do `phpinfo()`.
- Arquivo `phpinfo()` apagado do site.
- Comando antigo do cron copiado para um arquivo de texto.
- Comando novo com caminho absoluto do binário, caminho absoluto do script e `>> ... 2>&1`.
- Pasta de log criada.
- Comando testado no Terminal e log lido com `tail`.

Se depois disso o agendamento ainda falhar, o problema deixou de ser qual PHP está executando e passou a ser o que o script faz: credencial de banco, permissão de escrita, chamada externa bloqueada. O log do comando, aquele `>> ... 2>&1` que você acrescentou, é o que vai dizer qual dos três.

