--- title: "How to Create a phpinfo File to Check Your PHP Configuration in ISPConfig" description: "Use a temporary phpinfo file to see your site's PHP version, loaded php.ini, extensions and limits on ISPConfig hosting, then delete it straight away." url: "https://docs.noiz.ie/ispconfig/how-to-create-a-phpinfo-file-to-check-your-php-configuration-in-ispconfig/" section: "ISPConfig" categories: - "Control Panels > ISPConfig > ISPConfig Troubleshooting" last_reviewed: "27 July 2026, against the ISPConfig release Noiz runs and PHP’s built-in `phpinfo` function" --- # How to Create a phpinfo File to Check Your PHP Configuration in ISPConfig This guide shows you how to create a **phpinfo** file for a website on your Noiz hosting account so you can see exactly how PHP is configured for that site. A phpinfo file is a tiny PHP script (usually a single line) that, when opened in a browser, prints a full report of the running PHP setup: the active PHP version, which `php.ini` file is actually loaded, every extension that is turned on, and the effective limits such as `memory_limit` and `upload_max_filesize`. It is the quickest way to answer questions like “which PHP version is this site really running?”, “which php.ini do I need to edit?” and “did that extension actually load?”. It is written for Noiz clients whose websites run under ISPConfig, though the same file works on any PHP host. The report also exposes a great deal about the server, so the most important instruction in this guide is the one at the end: **delete the file the moment you are finished with it**. **Last reviewed:** 27 July 2026, against the ISPConfig release Noiz runs and PHP’s built-in `phpinfo` function. This guide is written for Noiz hosting and is kept current against ISPConfig and PHP. It complements, and does not replace, the official documentation linked below. The `phpinfo()` output itself is a standard PHP feature and looks the same on any host; ISPConfig details can vary slightly between releases, so if a screen differs, check the official links. ### Official Documentation Reference - [phpinfo() (PHP Manual)](https://www.php.net/manual/en/function.phpinfo.php): the official reference for the function that produces the report, including what each section contains. - [The configuration file php.ini (PHP Manual)](https://www.php.net/manual/en/configuration.file.php): how PHP finds and layers its configuration files, which explains the **Loaded Configuration File** and **Additional .ini files** lines in the report. - [ISPConfig Documentation](https://docs.ispconfig.org/): the official documentation covering website PHP mode and per-site PHP version selection. ## Prerequisites - A website on your Noiz account whose PHP configuration you want to inspect. - A way to upload a file into the site’s document root: an FTP or SFTP client such as FileZilla or WinSCP with the login details for that website, or a web file manager if your plan provides one. - To read the site’s PHP mode and version in the panel, the ability to [log in to the ISPConfig control panel](/ispconfig/how-to-log-in-to-the-ispconfig-control-panel/). This is optional; the phpinfo file works without it. ## Read This First: The Security Warning A phpinfo report is a gift to anyone probing your server. It reveals the exact PHP version (making it easy to look up known vulnerabilities for that release), the full list of loaded extensions and their versions, absolute file-system paths, the web server and its version, environment variables, and more. Leaving one on a live site is a well-known reconnaissance target and is routinely scanned for by bots. Treat the file as strictly temporary. The safe pattern is: - Give it an **unpredictable name**, not `phpinfo.php` or `info.php`, which are the first names an attacker guesses. - Open it, read what you need, and **delete it straight away**. - Never leave it in place “for later”. If you need it again, it takes ten seconds to recreate. The deletion step is covered in its own section below, and it is not optional. ## Create the phpinfo File The file contains a single PHP function call. Everything else is optional. ### Write the Script On your own computer, create a plain text file and put exactly this inside it: ``` ### Open It in a Browser Using `yourdomain.com` as an example for your real domain, go to the file’s address, matching the exact file name you chose: ``` https://yourdomain.com/phpcheck-7f3a9.php ``` You should see the familiar purple-and-grey PHP information table. If you see the raw ` ## What to Look For in the Report The report is long, but for the common questions you only need a handful of lines. Use your browser’s find function (`Ctrl`+`F`, or `Cmd`+`F` on a Mac) to jump to each one. ### The Active PHP Version The big heading at the very top reads **PHP Version 8.x.x** (or whichever version applies). This is the version the website is genuinely executing, which is the only version that matters when a plugin or application says it needs a minimum PHP release. It can differ from what a command-line check reports, which is why the browser view is the authoritative one for a website. ### The php.ini That Is Actually Loaded Search for **Loaded Configuration File**. Its value is the full path to the main `php.ini` the site is using, for example `/etc/php/8.2/fpm/php.ini`. This is the single most useful line in the whole report: it tells you precisely which file governs the settings, so you are never editing the wrong one. Just below it, **Scan this dir for additional .ini files** and **Additional .ini files parsed** list the extra fragment files (often one per extension) that PHP loads on top of the main file. If a setting is not where you expect it in the main `php.ini`, it is frequently being set in one of these fragments instead. On an ISPConfig site the path is also a clue to how any per-site override was applied. A site in PHP-FPM mode loads the server-wide `php.ini` for its PHP version, because its custom settings are written into that site’s own FPM pool configuration rather than into a separate `php.ini`. A site in Fast-CGI, CGI or SuPHP mode that has custom settings gets a generated per-site `php.ini` instead, so the path points into the site’s own configuration directory rather than the system one under `/etc`. ### Which PHP Mode Is in Use Search for **Server API**. A value such as `FPM/FastCGI`, `CGI/FastCGI`, or `Apache 2.0 Handler` tells you which PHP mode the site runs under. This maps directly to the PHP mode set for the website in ISPConfig (PHP-FPM, Fast-CGI, and so on), which is useful when a change you made in the panel does not seem to be taking effect: the Server API confirms the mode PHP is really serving requests with. ### Whether an Extension Is Loaded Each enabled extension has its own titled section in the report, for example **gd**, **curl**, **mysqli**, **intl**, **imagick**, or **opcache**. To confirm one is present, use find to search for its name: if there is a section header for it, it is loaded; if there is no match anywhere on the page, it is not enabled for this site’s PHP version. This is the fastest way to settle an application’s “required extension” error. ### The Effective Limits: Local and Master Values In the **Core** section near the top you will find the limits people most often need to check: - `memory_limit`: how much memory a single script may use. - `upload_max_filesize` and `post_max_size`: the largest file, and the largest whole request, that can be uploaded. - `max_execution_time`: how long a script may run before it is stopped. - `max_input_vars`: how many form or array fields a request may contain (a common culprit behind large menus or imports silently failing). Each setting shows two columns: **Local Value** and **Master Value**. The **Local Value** is what is actually in force for this request. The **Master Value** is the starting value before any change made at run time, for example by a `.user.ini` file or by the application itself. On an ISPConfig site, anything entered in the **Custom php.ini settings** field on the website’s **Options** tab is applied at that starting level: under PHP-FPM it is written into the site’s pool configuration, and under Fast-CGI or CGI into its per-site `php.ini`. It therefore usually shows in both columns, so confirm an override by checking that the value itself reads what you asked for, rather than looking for a difference between the columns. That tab is shown only to administrator logins, and to reseller logins where the server permits it, so on a Noiz-managed site the change is made for you: ask the Noiz support team for the limit you need, then reload the phpinfo page and check the Local Value. Always trust the **Local Value** as the real limit for the site. ## How This Fits ISPConfig’s Per-Site PHP ISPConfig lets each website choose its own PHP handling, which is exactly why a phpinfo check is worth doing per site rather than assuming a server-wide answer. Open the site under **Sites > Websites > Website**: two fields on its **Domain** tab shape what the report will say: - **PHP**, which either disables PHP for the site or sets the mode it runs under (PHP-FPM, Fast-CGI, and similar). The report reflects the mode in its **Server API** line. - **PHP Version**, which selects among the PHP releases installed on the server. This dropdown appears only when **PHP** is set to Fast-CGI or PHP-FPM; the other modes always run the server’s default PHP, so there is nothing to choose. Two sites on the very same Noiz account can therefore run different PHP versions, and each has its own `php.ini` and its own set of loaded extensions. Because of this, the version and extensions shown by a phpinfo file placed on one site apply to that site only. If you change the **PHP Version** for a site in ISPConfig and reload the phpinfo page, the version at the top should change to match, confirming the switch worked. The **Loaded Configuration File** path usually changes with it, because each PHP release keeps its own configuration directory, though a site whose settings are served from a generated per-site `php.ini` keeps the same path. ![ISPConfig website Domain tab showing the PHP mode dropdown and the PHP Version dropdown used to pick the release for the site](/images/kb/265_ispconfig-domain-tab-php-version.png) ## Delete the File Immediately Afterwards As soon as you have read what you need, remove the file. Do not skip this. 1. Reconnect (or return) to your FTP or SFTP session for the site. 2. Open the same `web` document-root folder. 3. Delete the `phpcheck-7f3a9.php` file you uploaded. 4. Reload the file’s address in your browser. You should now get a **404 Not Found**, which confirms it is gone. If you ever find an old `info.php`, `phpinfo.php`, or similar left behind on a site, delete it as well: an out-of-date report is just as revealing to an attacker as a fresh one. ## A Safer Alternative for Shell Accounts If your service includes shell access over SSH (Noiz VPS, dedicated servers, and shell-user accounts), you can inspect PHP without exposing anything on the web at all. From the command line: ``` php -v ``` prints the version, and ``` php -i ``` prints the same information as a phpinfo page, in plain text. To jump straight to one setting, filter it, for example: ``` php -i | grep memory_limit ``` Where several PHP releases are installed, call the specific one by its versioned binary, such as `php8.2 -i`, to be sure which you are querying. One caveat: the command line uses the **CLI** build of PHP, which can load a different `php.ini` and different limits from the **FPM/FastCGI** build that serves your website. For the values a visitor’s request actually sees, the browser-based phpinfo file remains the definitive check; the command line is the convenient, exposure-free option for the CLI environment. ## Troubleshooting - **The browser shows the raw `