How to Parse and Process HTML/XML in PHP

By the end of this page, you will understand the main ways to parse HTML and XML in PHP, when to use DOMDocument, DOMXPath, and SimpleXML, and how to extract text, attributes, and elements from structured markup.

Parsing HTML or XML means turning raw markup text into a structure that your PHP code can navigate.

Instead of searching with fragile string operations like strpos() or regular expressions, a parser understands the document as elements, attributes, text nodes, and hierarchy.

In PHP, the most common built-in tools are:

• DOMDocument for loading and traversing HTML or XML as a tree
• DOMXPath for querying that tree with XPath expressions
• SimpleXML for simpler XML reading when the structure is clean and predictable

Why this matters:

• HTML and XML are nested formats, so structure matters
• Manual string parsing breaks easily when formatting changes
• Parsers let you safely access tags, attributes, and text
• XPath makes complex searches much easier

A common beginner mistake is trying to parse HTML with regular expressions. That usually fails because HTML is not just plain text—it is a nested document format with optional whitespace, attributes, child elements, and inconsistent formatting.

HTML vs XML in PHP

Although they look similar, PHP usually handles them slightly differently:

• HTML is often imperfect and forgiving
• XML must be well-formed

That means:

• Use DOMDocument::loadHTML() for HTML
• Use DOMDocument::loadXML() or simplexml_load_string() for XML

If you need flexible searching in either format, XPath is one of the most useful tools.

Think of an HTML or XML document like a family tree.

• Each tag is a person
• Parent tags contain child tags
• Attributes are like labels attached to each person
• Text inside a tag is that person's content

Parsing means building that family tree in memory.

Once the tree exists, you can:

• go to a specific branch
• find all children with a certain name
• read labels such as id, class, or href
• collect text from matching nodes

Without parsing, you are guessing by searching raw text. With parsing, you are navigating a real structure.

Using DOMDocument for HTML

<?php
$html = '<div><a href="/post/1">Read more</a></div>';

$dom = new DOMDocument();
libxml_use_internal_errors(true); // suppress warnings for imperfect HTML
$dom->loadHTML($html);
libxml_clear_errors();

$links = $dom->getElementsByTagName('a');

foreach ($links as $link) {
    echo $link->getAttribute('href') . PHP_EOL;
    echo $link->textContent . PHP_EOL;
}

This example:

• loads an HTML string
• finds all <a> elements
• reads each link's href attribute
• reads the visible text inside the link

Using DOMXPath for more precise queries

<?php
$html = '<div><p class="name">Alice</p></div>';

$dom = new DOMDocument();
libxml_use_internal_errors(true);
$dom->loadHTML($html);
libxml_clear_errors();

$paragraphs = $dom->getElementsByTagName('p');
$firstParagraph = $paragraphs->item(0);

echo $firstParagraph->getAttribute('class') . PHP_EOL;
echo $firstParagraph->textContent . PHP_EOL;

Step by step:

1. $html stores the raw HTML string.
2. $dom = new DOMDocument(); creates a parser object.
3. libxml_use_internal_errors(true); tells PHP not to print parser warnings directly.
4. $dom->loadHTML($html); parses the HTML and builds a document tree.
5. libxml_clear_errors(); clears any stored parsing warnings.

Parsing HTML and XML in PHP is useful in many everyday tasks:

• Web scraping: extract titles, links, prices, or metadata from HTML pages
• API integrations: read XML responses from older web services or feeds
• RSS/Atom feed processing: collect article titles, links, and publish dates
• Import tools: load product catalogs, invoices, or configuration files in XML format
• Content migration: extract data from old CMS-generated HTML
• Server-side validation: inspect generated HTML in tests or processing pipelines

Example scenarios:

• A script reads an RSS feed and stores article titles in a database
• An admin tool imports XML product data from a supplier
• A crawler extracts all links from a page for indexing
• A test script checks whether generated HTML contains expected elements

In real projects, developers usually combine parsing with a few common patterns.

Validation before processing

Check whether parsing succeeded before using the result.

<?php
$xml = '<user><name>Sam</name></user>';
$data = simplexml_load_string($xml);

if ($data === false) {
    echo 'Invalid XML';
    return;
}

echo (string) $data->name;

Guard clauses for missing nodes

<?php
$linkNode = $dom->getElementsByTagName('a')->item(0);

if ($linkNode === null) {
    return;
}

echo $linkNode->getAttribute('href');

Extracting arrays of values

 = [];
 = ->();

 (  ) {
    [] = [
         => (->textContent),
         => ->(),
    ];
}

1. Using regular expressions to parse HTML

Broken approach:

<?php
preg_match('/<a href="(.*?)">(.*?)<\/a>/', $html, $matches);

Why it is a problem:

• breaks on nested tags
• breaks on single quotes or different spacing
• fails when the HTML structure changes

Use DOMDocument instead.

2. Forgetting that HTML and XML use different loaders

Broken approach:

<?php
$dom = new DOMDocument();
$dom->loadXML('<div><p>Hello</p></div>');

This is not valid XML unless it is properly formed as XML and follows XML rules.

Use:

• loadHTML() for HTML
• loadXML() for real XML

3. Not checking for missing nodes

Broken code:

<?php
 = ->()->();
 ->textContent;

DOMDocument vs

Quick reference

Load HTML with DOMDocument

$dom = new DOMDocument();
libxml_use_internal_errors(true);
$dom->loadHTML($html);
libxml_clear_errors();

Load XML with DOMDocument

$dom = new DOMDocument();
$dom->loadXML($xml);

Find elements by tag name

$nodes = $dom->getElementsByTagName('a');

Read text and attributes

$text = $node->textContent;
$href = $node->getAttribute('href');

How do I parse HTML in PHP?

Use DOMDocument::loadHTML() to load the HTML, then use getElementsByTagName() or DOMXPath to find elements and extract data.

How do I parse XML in PHP?

You can use DOMDocument::loadXML() or simplexml_load_string(). SimpleXML is easier for simple XML structures.

Should I use regex to parse HTML in PHP?

Usually no. HTML is nested and inconsistent, so regex is fragile. A parser like DOMDocument is more reliable.

What is XPath in PHP?

XPath is a query language for selecting nodes from an HTML or XML document. In PHP, you use it through DOMXPath.

Why does loadHTML() show warnings?

Real-world HTML is often imperfect. Use libxml_use_internal_errors(true) before parsing and libxml_clear_errors() after.

What is the difference between DOMDocument and SimpleXML?

DOMDocument is more flexible and supports HTML and XML. is simpler but mainly for straightforward XML.

• DOM tree — Parsing creates a tree of nodes that you can traverse.
• XPath — Useful for selecting elements by tag, attribute, or position.
• XML well-formedness — Important because XML parsing fails if the document is not properly structured.
• HTML document structure — Helps you understand parent, child, and sibling elements.
• Attributes and text nodes — These are the main pieces of data you usually extract.
• Web scraping — A common practical use of HTML parsing.
• RSS and Atom feeds — Real examples of XML processing in applications.
• Input validation — Important when handling external documents that may be malformed.