Check TYPO3 Version, Composer Mode & Site Root - 2026 Guide

Quick Reference: Which Method Should I Use?

Use the method that matches your access level. Backend access is fastest for administrators, CLI is best for developers, PHP code is best inside extensions, and Composer files are useful for repository or server audits.

If you only have the public URL, use a fingerprinting tool for a major-version estimate.

The fastest way for most developers is CLI:

./vendor/bin/typo3 --version

In DDEV:

ddev exec ./vendor/bin/typo3 --version

In Docker:

docker exec -it my_php_container ./vendor/bin/typo3 --version

TYPO3 Version Support Status in 2026 - What You Need to Know First

After you check TYPO3 version, confirm whether that version still receives free security updates.

In 2026, TYPO3 v14 LTS is the recommended version for new projects, TYPO3 v13 LTS remains supported for existing sites, and TYPO3 v12.4 LTS has moved into ELTS-only status after free support ended on April 30, 2026.

The official TYPO3 download page lists TYPO3 14 LTS with free support until June 30, 2029 and ELTS until June 30, 2032. It also lists TYPO3 13 LTS with free support until December 31, 2027, TYPO3 12 ELTS with free support ended April 30, 2026, TYPO3 11 ELTS with free support ended October 31, 2024, and TYPO3 10 ELTS with free support ended April 30, 2023.

What ELTS Means and When to Use It

ELTS means Extended Long Term Support. It is paid vendor support for expired TYPO3 LTS versions. ELTS can be useful when a business-critical site cannot be upgraded immediately, but it should usually be treated as a temporary bridge, not a long-term upgrade strategy.

2026 Alert: TYPO3 v12 Reached End-of-Life

TYPO3 v12.4 LTS reached the end of free community support on April 30, 2026. If your site is still on v12, you should either move to ELTS or plan an upgrade to v13 or v14. This matters because free security updates are no longer available for v12 after that date.

Why Checking Your TYPO3 Version Matters

A TYPO3 version refers to the specific release number of the TYPO3 CMS you’re using. Each version comes with its own set of features, performance improvements, security updates, and compatibility requirements.

TYPO3 uses a versioning format like v12 LTS or v13.1, where:

• The number indicates the major or minor release
• LTS stands for Long-Term Support, offering extended updates for up to 3 years

Your TYPO3 version affects security updates, PHP compatibility, extension compatibility, upgrade planning, and developer tooling. 

In 2026, version checking is especially important because TYPO3 v14 LTS is now the flagship version, TYPO3 v13 remains actively supported, and TYPO3 v12 has moved into ELTS-only status.

A TYPO3 version number usually follows this pattern:

13.4.30

Here:

13 = major version
4  = minor / LTS branch
30 = patch version

For audits, the patch version matters because security and maintenance releases are delivered as patch updates. For upgrade planning, the major and LTS branch matter most.

Method 1: TYPO3 Backend - Quickest for Admins

If you have backend access, the TYPO3 backend is usually the fastest way to check TYPO3 version. Log in to /typo3/ and check the backend interface, system information area, or system reports.

This method is best for admins, editors, and maintainers who do not need CLI or server access.

Log in to your TYPO3 backend:

https: //example.com/typo3/

Then check the backend footer, system information area, or system reports depending on the TYPO3 version and backend configuration.

In TYPO3 v14, the backend interface is visually different from v12 and v13 because the v14 LTS release includes a modernized backend UI. The TYPO3 v14 LTS release announcement highlights a redesigned backend, a default frontend theme, QR code and short URL modules, and the Context Panel.

Admin Panel in v13 and v14.3 LTS

In TYPO3 v13, backend version checks look familiar to most existing TYPO3 administrators. In TYPO3 v14.3 LTS, the backend has changed significantly, so do not rely on older screenshots alone. If you are preparing this article for publication, add fresh v14.3 backend screenshots near this section.

Method 2: How to Check TYPO3 Version Without Backend Access

You can check TYPO3 version without backend access by reviewing Composer files, checking server-side package metadata, using CLI access, or scanning the public site with a fingerprinting tool. 

This is useful during client audits, takeover projects, security reviews, and situations where backend credentials are missing or unavailable. 

Using t3versions.com

t3versions.com is useful when you only have the public website URL. The tool attempts to determine the TYPO3 major version for one or multiple URLs. Its FAQ says it checks frontend output, backend login if available, and file fingerprints unique to TYPO3 major versions.

Use it as an estimate, not as your only source of truth. Public fingerprinting can be blocked by security settings, custom deployments, reverse proxies, CDN rules, or hardened file access.

Reading composer.json and composer.lock

In Composer-based TYPO3 installations, check the project root for:

composer.json
composer.lock
vendor/
public/
config/
var/

Open composer.json and look for TYPO3 package constraints:

{
"require": {
  "typo3/cms-core": "^14.3"
}
}
For the exact installed version, check composer.lock:
{
"name": "typo3/cms-core",
"version": "14.3.2"
}

composer.json tells you the allowed version range. composer.lock tells you the installed package version after dependency resolution.

Reading Vendor Package Files

If you have server access but cannot use the backend, inspect the TYPO3 core package under:

vendor/typo3/cms-core/

In a Composer installation, the installed package metadata and lock file are usually more reliable than guessing from frontend assets.

Security Note

Do not expose exact TYPO3 patch versions publicly unless there is a clear reason. A public major-version estimate can help with audits, but exact patch-level disclosure may give attackers unnecessary detail about outdated installations.

Method 3: PHP Code - Typo3Version Class for v11+

Use the Typo3Version class to detect TYPO3 version programmatically in TYPO3 v11 and newer. It returns the exact version, major version, and branch without relying on deprecated global constants. 

This is the recommended method for extensions, site packages, compatibility checks, and conditional code paths in v13 and v14.

<?php

use TYPO3\CMS\Core\Information\Typo3Version;
use TYPO3\CMS\Core\Utility\GeneralUtility;

$typo3Version = GeneralUtility::makeInstance(Typo3Version::class);

echo $typo3Version->getVersion();       // Example: 14.3.2
echo $typo3Version->getMajorVersion();  // Example: 14
echo $typo3Version->getBranch();        // Example: 14.3

Use this when you need conditional code paths:

<?php

use TYPO3\CMS\Core\Information\Typo3Version;
use TYPO3\CMS\Core\Utility\GeneralUtility;

$typo3Version = GeneralUtility::makeInstance(Typo3Version::class);

if ($typo3Version->getMajorVersion() >= 14) {
  // TYPO3 v14+ logic
}

TYPO3 deprecated the global constants TYPO3_version and TYPO3_branch and introduced \TYPO3\CMS\Core\Information\Typo3Version as the replacement API for the same information.

Method 4: PHP Constants - Legacy Only, Deprecated

Use TYPO3_version and TYPO3_branch only for legacy compatibility. These constants are deprecated, and modern TYPO3 code should use the Typo3Version class instead.

Keep constant-based checks only where old extensions or legacy installations still require them, especially in older v8, v9, or transitional projects.

<?php

echo TYPO3_version;
echo TYPO3_branch;

For legacy checks:

<?php

if (version_compare(TYPO3_version, '12.4.0', '>=')) {
  // TYPO3 v12.4+ logic
}

In modern TYPO3 development, use Typo3Version instead:

<?php

$version = GeneralUtility::makeInstance(Typo3Version::class)->getVersion();

The constants were marked deprecated in TYPO3 v10.3, and TYPO3’s changelog points developers to the Typo3Version class instead.

Method 5: CLI - TYPO3 Console, DDEV, and Docker

CLI is the most reliable method when you have project, SSH, DDEV, or Docker access. Run ./vendor/bin/typo3 --version from the TYPO3 project root, or execute the same command inside the active DDEV or Docker container.

This confirms the version from the real runtime environment. 

Standard Composer Install

From the TYPO3 project root:

./vendor/bin/typo3 --version

If the binary is not executable:

php vendor/bin/typo3 --version

TYPO3’s official console command documentation explains that the vendor/bin/typo3 entry point is used for Composer-based installations and that commands may need to run inside the correct local, Docker, or server environment.

DDEV Local Environment

For DDEV projects, run:

ddev exec ./vendor/bin/typo3 --version

You can also try:

ddev typo3 --version

TYPO3’s Getting Started documentation uses DDEV and Composer for local TYPO3 installation and shows DDEV-based TYPO3 CLI commands during setup.

Docker / Container Environments

If TYPO3 runs inside a Docker PHP container, execute the command inside the container:

docker exec -it my_php_container bash
cd /var/www/html
./vendor/bin/typo3 --version

Or run it directly:

docker exec -it my_php_container ./vendor/bin/typo3 --version

TYPO3’s CLI documentation notes that, when using Docker directly, TYPO3 commands usually need to be executed inside the PHP/TYPO3 container.

Legacy CLI for TYPO3 v8 and Earlier

For older Classic-mode installations, the CLI path may look like this:

typo3/sysext/core/bin/typo3 --version

Use this only for legacy systems. For TYPO3 v13 and v14, expect Composer-first project structures.

How to Detect Composer Mode in TYPO3

Use Environment::isComposerMode() to detect Composer mode in TYPO3 v9 and newer. In Composer-based projects, it returns true; in Classic-mode installations, it returns false. You can also check for composer.json, composer.lock, and vendor/, but the PHP API is more reliable inside TYPO3.

File System Check

A Composer-based TYPO3 project usually contains:

composer.json
composer.lock
vendor/
public/
config/
var/

A legacy Classic-mode installation may contain structures such as:

typo3/

typo3conf/

typo3temp/

fileadmin/

This file check is useful during audits, but PHP code is more reliable inside TYPO3.

PHP Code v9+ - Environment::isComposerMode()

Use the TYPO3 Environment API:

<?php

use TYPO3\CMS\Core\Core\Environment;

if (Environment::isComposerMode()) {
  echo 'Composer mode';
} else {
  echo 'Classic mode';
}

TYPO3 introduced the Environment class with methods including Environment::isComposerMode(), Environment::getProjectPath(), and Environment::getPublicPath(). The changelog also recommends using the Environment class instead of older path constants.

PHP Code v8 - Bootstrap::usesComposerClassLoading()

For old TYPO3 v8 projects:

<?php

use TYPO3\CMS\Core\Core\Bootstrap;

if (Bootstrap::usesComposerClassLoading()) {
  echo 'Composer mode';
}

Keep this only for legacy maintenance. It is not the preferred approach for current TYPO3 versions.

Why Composer Mode Matters in 2026

Composer mode matters because TYPO3 v14 has moved even more strongly toward Composer-first extension metadata and dependency handling. The TYPO3 documentation states that ext_emconf.php is deprecated, and version/dependency metadata should now be defined in an extension’s composer.json.

Migrating from Classic to Composer Mode

A Classic-to-Composer migration usually involves:

1. Backing up files and database.
2. Creating a Composer-based TYPO3 project.
3. Requiring TYPO3 core packages and extensions through Composer.
4. Moving custom extensions into a Composer-friendly package structure.
5. Migrating configuration, public assets, and environment-specific settings.
6. Testing backend, frontend, scheduler, CLI, and deployment workflows.

For TYPO3 v13 and v14 projects, Composer should be the default for new builds and serious long-term maintenance.

Locating the TYPO3 Site Root

Use Environment::getPublicPath() and Environment::getProjectPath() to locate TYPO3 paths in modern installations.

In Composer-based projects, the public web root is often public/, while the project root contains composer.json, vendor/, config/, and var/. This distinction is important for deployments, containers, and extension code.

Environment::getPublicPath() and getProjectPath() for v9+

Use the Environment API:

<?php

use TYPO3\CMS\Core\Core\Environment;

$publicPath = Environment::getPublicPath();
$projectPath = Environment::getProjectPath();

echo $publicPath;
echo $projectPath;

Typical Composer structure:

/project-root
composer.json
composer.lock
vendor/
config/
var/
public/
  index.php
  typo3/

Environment::getProjectPath() return the root-level project path, while Environment::getPublicPath() returns the publicly accessible folder previously known as PATH_site.

PATH_site for v8 and Earlier

Legacy TYPO3 installations may use:

<?php

echo PATH_site;

Full Cross-Version Implementation

<?php

if (class_exists(\TYPO3\CMS\Core\Core\Environment::class)) {
  $publicPath = \TYPO3\CMS\Core\Core\Environment::getPublicPath();
  $projectPath = \TYPO3\CMS\Core\Core\Environment::getProjectPath();
} else {
  $publicPath = defined('PATH_site') ? PATH_site : null;
  $projectPath = $publicPath;
}

echo 'Public path: ' . $publicPath . PHP_EOL;
echo 'Project path: ' . $projectPath . PHP_EOL;

Site Root in Docker / Containerized TYPO3 Deployments

In Docker, the project path inside the container may differ from the host path. For example, the host project may be in:

~/Projects/my-typo3-site

But inside the container it may be mounted as:

/var/www/html

Run path checks inside the PHP container when debugging Composer mode, CLI output, or runtime paths.

TYPO3 v14.3 LTS - Developer Guide

TYPO3 v14.3 LTS is the current flagship line for new TYPO3 projects in 2026. It supports PHP 8.2 through PHP 8.5, uses Composer-first extension metadata, modernizes the backend, and receives security support until June 30, 2029. 

New projects should normally target v14 unless project constraints require v13.

TYPO3 14 LTS is listed as recommended for new projects, supports PHP 8.2, 8.3, 8.4, and 8.5, and receives free support until June 30, 2029.

Version Check with Typo3Version Class

<?php

use TYPO3\CMS\Core\Information\Typo3Version;
use TYPO3\CMS\Core\Utility\GeneralUtility;

$version = GeneralUtility::makeInstance(Typo3Version::class);

if ($version->getMajorVersion() === 14) {
  echo 'TYPO3 v14 project';
}

What Is New in v14.3 LTS for Developers?

TYPO3 v14 includes major developer-facing changes such as Fluid 5.0, Symfony Translation Component integration, System Resource API for file access and public URI generation, XLIFF 2.x translation support, default theme Camino, and Extbase-related improvements including validation attributes and rate limiting for Extbase actions.

For version and environment checks, the key takeaway is simple: use modern APIs, avoid deprecated constants, and assume Composer-first project structures.

ext_emconf.php Deprecated - Replaced by composer.json

Example extension requirement:

{
"require": {
  "typo3/cms-core": "^13.4 || ^14.3"
},
"extra": {
  "typo3/cms": {
    "extension-key": "my_extension"
  }
}
}

PHP 8.2–8.5 Support Window

TYPO3 14 LTS supports PHP 8.2, 8.3, 8.4, and 8.5. This is important when planning hosting, CI pipelines, Docker images, and future upgrades.

Support Timeline

TYPO3 v14 LTS receives free security support until June 30, 2029 and ELTS until June 30, 2032. For new projects in 2026, this makes v14 the strongest long-term option.

Environment API as the Standard Approach

Use the Environment API for project paths, public paths, application context, and Composer mode checks:

<?php

use TYPO3\CMS\Core\Core\Environment;

Environment::isComposerMode();
Environment::getProjectPath();
Environment::getPublicPath();
Environment::getContext();

TYPO3 v13.4 LTS - Still Supported, Still Receiving Security Updates

TYPO3 v13.4 LTS remains a safe production choice for existing projects in 2026. It continues to receive security updates until December 31, 2027, making it suitable for sites that are stable on v13 but not yet ready for v14. 

New builds, however, should usually evaluate TYPO3 v14 LTS first. Use the same modern version-checking APIs:

<?php

use TYPO3\CMS\Core\Information\Typo3Version;
use TYPO3\CMS\Core\Utility\GeneralUtility;

$typo3Version = GeneralUtility::makeInstance(Typo3Version::class);

if ($typo3Version->getBranch() === '13.4') {
  echo 'TYPO3 v13.4 LTS';
}

TYPO3 13 LTS is listed for existing projects and receives free support until December 31, 2027.

TYPO3 v12.4 LTS - EOL April 30, 2026

TYPO3 v12.4 LTS is no longer free-supported after April 30, 2026. Sites still running v12 should either buy ELTS coverage or plan an upgrade to v13 or v14. TYPO3’s ELTS page lists support options up to April 30, 2030, with the fourth year reserved for TYPO3 Partners.

If you maintain a v12 project, keep existing code examples working, but add upgrade urgency to the technical documentation:

<?php

use TYPO3\CMS\Core\Core\Environment;

if (method_exists(Environment::class, 'isRunningInContainer')) {
  $runningInContainer = Environment::isRunningInContainer();
}

You can also check application context:

<?php

use TYPO3\CMS\Core\Core\Environment;

$context = Environment::getContext();
echo (string)$context;

For v12 sites, the next practical step is not only to check TYPO3 version, but to decide whether the site moves to ELTS temporarily or upgrades to v13/v14.

TYPO3 v11 - ELTS Only

TYPO3 v11 is a legacy version in 2026 and should be treated as ELTS-only. Keep v11 guidance only for maintenance, audits, or staged upgrade planning.

If a site still runs v11, review PHP compatibility, Composer status, extensions, templates, and deployment workflows before planning a controlled upgrade path.

<?php

use TYPO3\CMS\Core\Information\Typo3Version;
use TYPO3\CMS\Core\Utility\GeneralUtility;

$version = GeneralUtility::makeInstance(Typo3Version::class);

echo $version->getVersion();

If a site still runs TYPO3 v11 in 2026, plan a staged upgrade. Jumping directly to v14 may require extension audits, PHP upgrades, template checks, Composer migration, and deployment changes.

Checking Extbase Classes in TYPO3

Check Extbase classes with class_exists(), interface_exists(), dependency injection, or reflection depending on the use case.

In TYPO3 v14, Extbase compatibility checks should also account for newer framework features, including Symfony-based validators and the security attributes #[Authorize] and #[RateLimit].

These features affect how modern Extbase controllers, actions, and validation logic are structured, so older reflection or class-existence checks should be combined with API-level compatibility review.

Method 1: class_exists()

<?php

if (class_exists(\Vendor\Extension\Domain\Model\Example::class)) {
  echo 'Class exists';
}

Method 2: interface_exists()

<?php

if (interface_exists(\TYPO3\CMS\Extbase\DomainObject\DomainObjectInterface::class)) {
  echo 'Extbase domain object interface available';
}

Method 3: Reflection

<?php

$reflection = new \ReflectionClass(\Vendor\Extension\Domain\Model\Example::class);

echo $reflection->getName();

In TYPO3 v14, Extbase gains additional modern features such as validation attributes and rate limiting support for Extbase actions, so old compatibility checks should be reviewed before assuming v14 readiness.

Best Practices and Common Pitfalls

The safest approach in 2026 is to use modern TYPO3 APIs, avoid deprecated constants, check Composer mode correctly, and run CLI commands inside the actual runtime environment. 

Do not treat v12 as free-supported, do not confuse public path with project path, and do not hardcode compatibility only around older TYPO3 versions.

Best Practices

• Start new projects on TYPO3 v14 LTS unless there is a clear project constraint. TYPO3 lists v14 LTS as recommended for new projects and v13 LTS as suitable for existing projects.
• Use Typo3Version for programmatic version checks:
• GeneralUtility::makeInstance(Typo3Version::class);
• Use Environment for Composer mode and path detection:
• Environment::isComposerMode();
• Environment::getProjectPath();
• Environment::getPublicPath();
• Check both composer.json and composer.lock. The first tells you allowed constraints; the second tells you the exact installed package version.
• For DDEV or Docker, always run CLI checks inside the same environment that executes TYPO3.

Common Pitfalls

• Do not use TYPO3_version or TYPO3_branch in new v13/v14 code. These constants are deprecated; use Typo3Version instead.
• Do not assume PATH_site means the project root in Composer mode. In modern projects, the public path and project path are different.
• Do not treat TYPO3 v12 as a currently free-supported version in 2026. It is ELTS-only after April 30, 2026.
• Do not rely only on frontend fingerprints when you need exact patch-level information. Use Composer, CLI, or backend/system data for exact results.
• Do not hardcode compatibility checks around v11–v13 only. For new code in 2026, include v14.3 LTS compatibility planning.

Conclusion

The correct method for checking the TYPO3 version depends on the available access. After checking, you should also verify whether the AI Foundation for TYPO3, along with connected providers, tools, and workflows, is compatible with the TYPO3 version currently in use or planned. Backend access is fastest for administrators, CLI is best for developers, Composer files help with server or repository audits, nd Typo3Version is the preferred PHP API for extension code.

After you check TYPO3 version, act on what you find. TYPO3 v14.3 LTS is the best target for new projects, TYPO3 v13.4 LTS is still safe for existing supported sites, and TYPO3 v12.4 LTS should now be treated as ELTS-only. 

For a legacy site, the next step is not just identifying the version, it is planning the upgrade path, checking Composer mode, reviewing extensions, and confirming the real project root before making changes.