What is XPath and what is it used for?

XPath is a query language for selecting parts of an XML (or HTML) document. You write a path-like expression and it returns the nodes that match — elements, attributes, text, or a computed string, number or boolean. Developers use it for web scraping, configuration parsing, XSLT transforms, Selenium and Playwright element selectors, and validating API responses.

Which XPath version does this tester support?

It uses your browser's built-in engine, which implements XPath 1.0. That covers the vast majority of everyday expressions — axes, predicates, and functions like count(), contains(), starts-with(), text(), local-name() and position(). XPath 2.0/3.1 features such as regular-expression matching, sequences and the ! operator are not part of the browser engine and will report an error.

Does my XML get uploaded anywhere?

No. Parsing and evaluation happen entirely inside your browser tab using the native DOMParser and document.evaluate APIs. Nothing is sent to a server, so it is safe for confidential configuration files, API payloads and internal data.

How do I select an attribute value rather than an element?

Prefix the attribute name with @. For example //book/@category returns the category attribute of every book, and //price[@currency='GBP'] selects price elements whose currency attribute equals GBP. The results table marks each row as element, attribute or text so you always know what you matched.

Why does my expression return no matches?

The three usual causes are a default namespace on the root element (the browser engine needs namespace-aware expressions, so try local-name()-based paths), a typo in an element or attribute name (XPath is case-sensitive), or a wrong axis — // searches the whole document while / starts from the root. Loading the sample and adjusting it step by step is the fastest way to find the problem.

Can I export the matched nodes?

Yes. For a node-set result you can copy just the values, copy a CSV with the index, path, node type and value columns, or download that CSV as a file. Scalar results (a string, number or boolean) can be copied directly. Everything is generated locally with the Blob API.

How are parse errors reported?

Before evaluating, the document is parsed and checked for well-formedness. If it is invalid, the tester shows a Well-formed or Invalid badge and surfaces the browser's parse message together with the line and column it could recover, so you can jump straight to the broken tag.

XPath Tester & Evaluator

An XPath tester that evaluates XPath 1.0 expressions against your XML and shows every matching node — its location path, its type and its value — the moment you press Evaluate. It is built for developers who write scrapers, XSLT stylesheets, Selenium or Playwright selectors, or anyone who needs to confirm exactly what a query will pull out of an XML payload before wiring it into code. The document, the current expression and a short history of recent queries are all kept in your browser, so a refresh never loses your work.

How it works

The tool leans on the browser’s own standards-compliant engine rather than a re-implementation, so results match what your application will see. First the XML is run through DOMParser. If the parser produces a parsererror, the tester reports the message along with the line and column it can recover and marks the document Invalid; otherwise you get a Well-formed badge. Then the expression is handed to document.evaluate with the ANY_TYPE result mode. The engine decides whether your expression produced a node-set, a string, a number or a boolean, and the result type is shown so there is never any ambiguity.

For a node-set, every matched node is iterated and rendered in a table. Each row carries a generated location path (with positional predicates like book[2] when siblings share a tag name), a type label — element, attribute, text, comment, CDATA or processing instruction — and the node’s value. Elements that contain child elements are serialised back to XML so you can see their structure; leaf elements and attributes show their text. Scalar results are shown verbatim. Because the engine is XPath 1.0, the full 1.0 function library is available, including count(), contains(), starts-with(), normalize-space(), position() and last().

Everything is computed locally. Nothing is uploaded, which makes the tester safe for private configuration files and unreleased API responses.

Example

Load the sample library document and try these expressions:

//book[@available='true']/title selects the titles of in-stock books — three matches, each marked as an element.
//book/@category returns every category attribute — the rows are typed as attribute.
count(//book) returns the number 3.
//title[@lang='fr']/text() selects the French title’s text node.
//book[price > 20]/author uses a numeric predicate to find authors of pricier books.

Switch the predicate to @available='false' and the match count drops, so you can verify a selector behaves exactly as intended before committing it. Use Copy CSV or Download CSV to hand the matched paths and values to a teammate, or click any entry in Recent expressions to re-run an earlier query.

Expression	Result type	Meaning
`//book/title`	node-set	every title element
`//book/@category`	node-set	every category attribute
`count(//book)`	number	how many books
`//book[1]/author/text()`	node-set	first author’s text
`boolean(//book[@available='true'])`	boolean	is anything in stock

Every figure and node is produced in your browser — your XML is never uploaded or stored on a server.