Skip to content
Go to file

PHP Domain Parser

PHP Domain Parser is domain parser implemented in PHP.

Quality Assurance Total Downloads Latest Stable Version Software License


While there are plenty of excellent URL parsers and builders available, there are very few projects that can accurately parse a domain into its component subdomain, registrable domain, second level domain and public suffix parts.

Consider the domain In this domain, the public suffix portion is, the registrable domain is, the subdomain is www and the second level domain is pref.
You can't regex that.

PHP Domain Parser is compliant around:

  • accurate Public Suffix List based parsing.
  • accurate Root Zone Database parsing.



$ composer require jeremykendall/php-domain-parser:^6.0

System Requirements

You need:

  • PHP >= 7.4 but the latest stable version of PHP is recommended
  • the intl extension


If you are upgrading from version 5 please check the upgrading guide for known issues.

Resolving Domains

This library can resolve a domain against:

In both cases this is done using the resolve method implemented on the resource instance. The method returns a Pdp\ResolvedDomain object which represents the result of that process.

For the Public Suffix List you need to use the Pdp\Rules class as shown below:

use Pdp\Rules;

$publicSuffixList = Rules::fromPath('/path/to/cache/public-suffix-list.dat');

$result = $publicSuffixList->resolve('www.PreF.OkiNawA.jP');
echo $result->domain()->toString();            //display '';
echo $result->subDomain()->toString();         //display 'www';
echo $result->secondLevelDomain();             //display 'pref';
echo $result->registrableDomain()->toString(); //display '';
echo $result->publicSuffix()->toString();      //display '';
$result->publicSuffix()->isICANN();            //return true;

For the IANA Root Zone Database, the Pdp\TopLevelDomains class is use instead:

use Pdp\TopLevelDomains;

$rootZoneDatabase = TopLevelDomains::fromPath('/path/to/cache/tlds-alpha-by-domain.txt');

$result = $rootZoneDatabase->resolve('www.PreF.OkiNawA.jP');
echo $result->domain()->toString();            //display '';
echo $result->publicSuffix()->toString();      //display 'jp';
echo $result->secondLevelDomain();             //display 'okinawa';
echo $result->registrableDomain()->toString(); //display '';
echo $result->subDomain()->toString();         //display 'www.pref';
echo $result->publicSuffix()->isIANA();        //return true

In case of an error an exception which extends Pdp\CannotProcessHost is thrown.

The resolve method will always return a ResolvedDomain even if the domain syntax is invalid or if there is no match found in the resource data. To work around this limitation, the library exposes more strict methods, namely:

  • Rules::getCookieDomain
  • Rules::getICANNDomain
  • Rules::getPrivateDomain

for the Public Suffix List and the following method for the Root Zone Database:

  • TopLevelDomains::getIANADomain

These methods resolve the domain against their respective data source using the same rules as the resolve method but will instead throw an exception if no valid effective TLD is found or if the submitted domain is invalid.

use Pdp\Rules;
use Pdp\TopLevelDomains;

$publicSuffixList = Rules::fromPath('/path/to/cache/public-suffix-list.dat');

// will throw because `.unknownTLD` is not part of the ICANN section

$result = $publicSuffixList->getCookieDomain('qfdsf.unknownTLD');
$result->publicSuffix()->value();   // returns 'unknownTLD'
$result->publicSuffix()->isKnown(); // returns false
// will not throw because the domain syntax is correct.

// will not throw because the domain syntax is invalid (ie: does not support public suffix)

$result = $publicSuffixList->resolve('com');
$result->publicSuffix()->value();   // returns null
$result->publicSuffix()->isKnown(); // returns false
// will not throw but its public suffix value equal to NULL

$rootZoneDatabase = TopLevelDomains::fromPath('/path/to/cache/public-suffix-list.dat');
// will not throw because the domain syntax is invalid (ie: does not support public suffix)

To instantiate each domain resolver you can use the following named constructor:

  • fromString: instantiate the resolver from a inline string representing the data source;
  • fromJsonString: instantiate the resolver from a json string representing the data source;
  • fromPath: instantiate the resolver from a local path or online URL by relying on fopen;

If the instantiation does not work an exception will be thrown.

Once instantiated, you can always convert the data source in a json encoded string as both resolver exposes the JsonSerialize method.


You should never use resolve domain name this way in production, without, at least, a caching mechanism to reduce PSL downloads.

Using the Public Suffix List to determine what is a valid domain name and what isn't is dangerous, particularly in these days when new gTLDs are arriving at a rapid pace.

If you are looking to know the validity of a Top Level Domain, the IANA Root Zone Database is the proper source for this information or alternatively consider using directly the DNS.

If you must use this library for any of the above purposes, please consider integrating an updating mechanism into your software.

For more information go to the Managing external data source section

Resolved domain information.

Whichever methods chosen to resolve the domain on success, the package will return a Pdp\ResolvedDomain instance.

The Pdp\ResolvedDomain decorates the Pdp\Domain class resolved but also gives access as separate methods to the domain different components.

use Pdp\RootZoneDatabase;

/** @var RootZoneDatabase $rootZoneDatabase */
$result = $rootZoneDatabase->resolve('www.PreF.OkiNawA.jP');
echo $result->domain()->toString();            //display '';
echo $result->publicSuffix()->toString();      //display 'jp';
echo $result->secondLevelDomain();             //display 'okinawa';
echo $result->registrableDomain()->toString(); //display '';
echo $result->subDomain()->toString();         //display 'www.pref';
echo $result->publicSuffix()->isIANA();        //return true

You can modify the returned Pdp\ResolvedDomain instance using the following methods:


use Pdp\PublicSuffixList;

/** @var PublicSuffixList $publicSuffixList */
$result = $publicSuffixList->resolve('');
$altResult = $result

echo $result->domain()->toString(); //display '';
$result->publicSuffix()->isKnown(); //returns true;

echo $altResult->domain()->toString(); //display '';
$altResult->publicSuffix()->isKnown(); //returns false;

TIP: Always favor submitting a Pdp\PublicSuffix object rather that any other supported type to avoid unexpected results. By default, if the input is not a Pdp\PublicSuffix instance, the resulting public suffix will be labelled as being unknown. For more information go to the Public Suffix section

Public Suffix

The domain effective TLD is represented using the Pdp\PublicSuffix. Depending on the data source the object exposes different information regarding its origin.

use Pdp\PublicSuffixList;

/** @var PublicSuffixList $publicSuffixList */
$publicSuffix = $publicSuffixList->resolve('')->publicSuffix();

echo $publicSuffix->domain()->toString(); //display '';
$publicSuffix->isICANN();                 //will return false
$publicSuffix->isPrivate();               //will return true
$publicSuffix->isIANA();                  //will return false
$publicSuffix->isKnown();                 //will return true

The public suffix state depends on its origin:

  • isKnown returns true if the value is present in the data resource.
  • isIANA returns true if the value is present in the Root Zone Database.
  • isICANN returns true if the value is present in the PSL ICANN section.
  • isPrivate returns true if the value is present in the PSL private section.

The same information is used when Pdp\PublicSuffix object is instantiate via its named constructors:

use Pdp\PublicSuffix;

$iana = PublicSuffix::fromIANA('');
$icann = PublicSuffix::fromICANN('');
$private = PublicSuffix::fromPrivate('');
$unknown = PublicSuffix::fromUnknown('');

Using a PublicSuffix object instead of a string or null with ResolvedDomain::withPublicSuffix will ensure that the returned value will always contain the correct information regarding the public suffix resolution.

Using a Domain object instead of a string or null with the named constructor ensure a better instantiation of the Public Suffix object for more information go to the ASCII and Unicode format section

Accessing and processing Domain labels

If you are interested into manipulating the domain labels without taking into account the Effective TLD, the library provides a Domain object tailored for manipulating domain labels. You can access the object using the following methods:

  • the ResolvedDomain::domain method
  • the PublicSuffix::domain method
  • from ResolvedDomain::subDomain method
  • the ResolvedDomain::registrableDomain returns a ResolvedDomain

Domain objects usage are explain in the next section.

use Pdp\PublicSuffixList;

/** @var PublicSuffixList $publicSuffixList */
$result = $publicSuffixList->resolve('');
$domain = $result->domain();
echo $domain->toString(); // display ''
count($domain);           // returns 4
$domain->labels();        // returns ['uk', 'co', 'bbc', 'www'];
$domain->label(-1);       // returns 'www'
$domain->label(0);        // returns 'uk'
foreach ($domain as $label) {
   echo $label, PHP_EOL;
// display 
// uk
// co
// bbc
// www

$publicSuffixDomain = $result->publicSuffix()->domain();
$publicSuffixDomain->labels(); // returns ['uk', 'co']

You can also add or remove labels according to their key index using the following methods:

use Pdp\PublicSuffixList;

/** @var PublicSuffixList $publicSuffixList */
$domain = $publicSuffixList->resolve('www.ExAmpLE.cOM')->domain();

$newDomain = $domain
    ->withLabel(1, 'com')  //replace 'example' by 'com'
    ->withoutLabel(0, -1)  //remove the first and last labels

echo $domain->toString();    // display ''
echo $newDomain->toString(); // display ''

WARNING: Because of its definition, a domain name can be null or a string.

To distinguish this possibility the object exposes two (2) formatting methods Domain::value which can be null or a string and Domain::toString which will always cast the domain value to a string.

use Pdp\Domain;

$nullDomain = Domain::fromIDNA2008(null);
$nullDomain->value();    // returns null;
$nullDomain->toString(); // returns '';

$emptyDomain = Domain::fromIDNA2008('');
$emptyDomain->value();    // returns '';
$emptyDomain->toString(); // returns '';

ASCII and Unicode formats.

Domain names originally only supported ASCII characters. Nowadays, they can also be presented under a UNICODE representation. The conversion between both formats is done using the compliant implementation of UTS#46, otherwise known as Unicode IDNA Compatibility Processing. Domain objects expose a toAscii and a toUnicode methods which returns a new instance in the converted format.

use Pdp\PublicSuffixList;

/** @var PublicSuffixList $publicSuffixList */
$unicodeDomain = $publicSuffixList->resolve('bébé.be')->domain();
echo $unicodeDomain->toString(); // returns 'bébé.be'

$asciiDomain = $publicSuffixList->resolve('')->domain();
echo $asciiDomain->toString();  // returns ''

$asciiDomain->toUnicode()->toString() === $unicodeDomain->toString(); //returns true
$unicodeDomain->toAscii()->toString() === $asciiDomain->toString();   //returns true

By default, the library uses IDNA2008 algorithm to convert domain name between both formats. It is still possible to use the legacy conversion algorithm known as IDNA2003.

Since direct conversion between both algorithms is not possible you need to explicitly specific on construction which algorithm you will use when creating a new domain instance via the Pdp\Domain object. This is done via two (2) named constructors:

  • Pdp\Domain::fromIDNA2008
  • Pdp\Domain::fromIDNA2003

At any given moment the Pdp\Domain instance can tell you whether:

  • the algorithm used for converting the domain is IDNA2008;
  • if the domain value is in ASCII mode or not;
use Pdp\Domain;

$domain = Domain::fromIDNA2008('faß.de');
echo $domain->value(); // display 'faß.de'
$domain->isIdna2008(); // returns true
$domain->isAscii();    // return false

$asciiDomain = $domain->toAscii(); 
echo $asciiDomain->value(); // display ''
$asciiDomain->isIdna2008(); // returns true
$asciiDomain->isAscii();    // returns true

$domain = Domain::fromIDNA2003('faß.de');
echo $domain->value(); // display ''
$domain->isIdna2008(); // returns false
$domain->isAscii();    // returns true

$asciiDomain = $domain->toAscii();
echo $asciiDomain->value(); // display ''
$asciiDomain->isIdna2008(); // returns false
$asciiDomain->isAscii();    // returns true

TIP: Always favor submitting a Pdp\Domain object for resolution rather that a string or an object that can be cast to a string to avoid unexpected format conversion errors/results. By default, and with lack of information conversion is done using IDNA 2008 rules.

Managing the package external resources

Depending on your application, the mechanism to store your resources may differ, nevertheless, the library comes bundle with a optional service which enables resolving domain name without the constant network overhead of continuously downloading the remote databases.

The interfaces defined under the Pdp\Storage namespace enable integrating a database managing system and provide an implementation example using PHP-FIG PSR interfaces.

The Pdp\Storage\PsrStorageFactory enables returning storage instances that retrieve, convert and cache the Public Suffix List and the IANA Root Zone Database using standard interfaces published by the PHP-FIG.

Instantiate Pdp\Storage\PsrStorageFactory

To work as intended, the Pdp\Storage\PsrStorageFactory constructor requires:

  • a PSR-16 Simple Cache implementing library.
  • a PSR-17 HTTP Factory implementing library.
  • a PSR-18 HTTP Client implementing library.

When creating a new storage instance you will require:

  • a $cachePrefix argument to optionally add a prefix to your cache index, default to the empty string;
  • a $ttl argument if you need to set the default $ttl, default to null to use the underlying caching default TTL;

The $ttl argument can be:

  • an int representing time in second (see PSR-16);
  • a DateInterval object (see PSR-16);
  • a DateTimeInterface object representing the date and time when the item will expire;

The package does not provide any implementation of such interfaces as you can find robust and battle tested implementations on packagist.

Refreshing the cached PSL and RZD data


For the purpose of this example we will use our PSR powered solution with:

  • Guzzle HTTP Client as our PSR-18 HTTP client;
  • Guzzle PSR-7 package which provide factories to create a PSR-7 objects using PSR-17 interfaces;
  • Symfony Cache Component as our PSR-16 cache implementation provider;

We will cache both external sources for 24 hours in a PostgreSQL database.

You are free to use other libraries/solutions/settings as long as they implement the required PSR interfaces.


use GuzzleHttp\Psr7\Request;
use Pdp\Storage\PsrStorageFactory;
use Psr\Http\Message\RequestFactoryInterface;
use Psr\Http\Message\RequestInterface;
use Symfony\Component\Cache\Adapter\PdoAdapter;
use Symfony\Component\Cache\Psr16Cache;

$pdo = new PDO(
$cache = new Psr16Cache(new PdoAdapter($pdo, 'pdp', 43200));
$client = new GuzzleHttp\Client();
$requestFactory = new class implements RequestFactoryInterface {
    public function createRequest(string $method, $uri): RequestInterface
        return new Request($method, $uri);

$cachePrefix = 'pdp_';
$cacheTtl = new DateInterval('P1D');
$factory = new PsrStorageFactory($cache, $client, $requestFactory);
$pslStorage = $factory->createPublicSuffixListStorage($cachePrefix, $cacheTtl);
$rzdStorage = $factory->createRootZoneDatabaseStorage($cachePrefix, $cacheTtl);

// if you need to force refreshing the rules 
// before calling them (to use in a refresh script)
// uncomment this part or adapt it to you script logic
// $pslStorage->delete(PsrStorageFactory::PUBLIC_SUFFIX_LIST_URI);
$publicSuffixList = $pslStorage->get(PsrStorageFactory::PUBLIC_SUFFIX_LIST_URI);

// if you need to force refreshing the rules 
// before calling them (to use in a refresh script)
// uncomment this part or adapt it to you script logic
// $rzdStorage->delete(PsrStorageFactory::ROOT_ZONE_DATABASE_URI);
$rootZoneDatabase = $rzdStorage->get(PsrStorageFactory::ROOT_ZONE_DATABASE_URI);

Be sure to adapt the following code to your own application. The following code is an example given without warranty of it working out of the box.

You should use your dependency injection container to avoid repeating this code in your application.

Automatic Updates

It is important to always have an up to date Public Suffix List and Root Zone Database.
This library no longer provide an out of the box script to do so as implementing such a job heavily depends on your application setup. You can use the above example script as a starting point to implement such a job.


Please see CHANGELOG for more information about what has been changed since version 5.0.0 was released.


Contributions are welcome and will be fully credited. Please see CONTRIBUTING for details.


pdp-domain-parser has:

  • a PHPUnit test suite
  • a coding style compliance test suite using PHP CS Fixer.
  • a code analysis compliance test suite using PHPStan.

To run the tests, run the following command from the project folder.

$ composer test


If you discover any security related issues, please email instead of using the issue tracker.



The MIT License (MIT). Please see License File for more information.


Portions of the Pdp\Converter and Pdp\Rules are derivative works of the PHP registered-domain-libs. Those parts of this codebase are heavily commented, and I've included a copy of the Apache Software Foundation License 2.0 in this project.

You can’t perform that action at this time.