XML to Table — View XML as a Sortable Table

XML is a tree, but the data inside it is usually a list — feed items, SOAP records, catalog entries, line items. Reading that as raw angle brackets is slow and error-prone. This tool flips it: paste your XML and it auto-detects the repeated elements and renders them as a real sortable, searchable table. No signup, no upload, all in your browser.

Free online tool · Updated 29 May 2026

Why a table beats raw XML

Say you have a feed like this:

<catalog>
  <product id="1"><name>Keyboard</name><price>49</price></product>
  <product id="2"><name>Mouse</name><price>19</price></product>
  <product id="3"><name>Monitor</name><price>229</price></product>
</catalog>

Pretty-printing re-indents the tags, which helps a little. But you still read it line by line, and you can't sort by price or scan for one product without re-reading the whole document. A table gives you the same data with each <product> as a row and its child tags as columns:

┌────┬──────────┬───────┐
│ ID │ NAME     │ PRICE │
├────┼──────────┼───────┤
│ 1  │ Keyboard │ 49    │
│ 2  │ Mouse    │ 19    │
│ 3  │ Monitor  │ 229   │
└────┴──────────┴───────┘

Now you can click Price to sort, type "monitor" to filter, and click a row to expand its full detail. The same data — but you scan it instead of parsing it in your head. That is the whole point of the converter, and it is the one thing most XML "viewers" don't actually do.

Convert XML to a table in three steps

1 Paste or upload your XML

Open prettyjsonxml.com and drop your XML into the editor in the middle of the page. You have two options:

Paste — click into the editor and press Ctrl+V (or Cmd+V on Mac). The editor highlights the markup as you go.
Upload — click the "Upload a file" button and pick any .xml file. It is parsed client-side; nothing is sent to a server.

2 Click "View as Table"

With your XML loaded, click View as Table in the toolbar above the editor. The viewer parses the document with the browser's native DOMParser, walks the tree to find the repeated element (the list inside your XML), and turns each occurrence into a row. Child tags and attributes become the columns.

3 Sort, search, expand

The table is now yours to drive:

Click any column header to sort ascending; click again for descending. Numeric columns sort numerically, text alphabetically.
Type in the search box to filter rows. The match is full-text — it covers visible cells and the nested content hidden in each row's detail.
Click any row to expand its complete element, including child elements, attributes, and any base64 image decoded as a thumbnail.

Open the viewer →

How repeated elements become rows

The converter doesn't ask you to write an XPath or pick a node by hand. It scans the parsed tree for the element that repeats most as a sibling set — <item> in an RSS feed, <product> in a catalog, a record element inside a SOAP body — and treats that as the row unit. Then it picks columns the same way the JSON table does:

Frequency. A child tag present on most rows is column-worthy. A tag on one row in fifty is a sparse outlier, kept available on expand.
Semantic priority. Tags named name, title, id, code, status, dates, and amounts get bumped to the front, because that is what people scan first.
Readable cap. The viewer shows a handful of the most useful columns rather than every tag, so a record with 30 children stays legible. The rest are one click away in the row detail.

Attributes, text, and nested tags

Real XML mixes attributes, element text, and deeper nesting. The converter handles each:

Attributes like id="1" are pulled out as their own columns alongside child-element text, so <product id="1"> gives you an ID column for free.
Singleton wrappers — when every row has the same single-child wrapper element, its fields are lifted to first-class columns instead of hiding a level down.
Deeper lists inside a row (a nested set of repeated tags) render as their own collapsible mini-table inside the expanded detail, recursively.

If you ever want the unfiltered structure, switch to Tree view — it renders the whole document as foldable nodes, preserving every tag, attribute, and text node.

SOAP, RSS, Atom, POM — it just works

Because detection is based on document shape rather than a fixed schema, the same converter handles the XML dialects people paste most:

SOAP responses — repeated records inside the envelope body become rows; header metadata stays accessible. See the SOAP response example.
RSS and Atom feeds — each <item> or <entry> becomes a row with title, link, and date columns. Try the Atom feed example.
Maven POM files — dependencies render as a clean table of group, artifact, and version. See the pom.xml example.

Large XML files (9 MB+)

The converter is built for big documents without freezing the tab:

Virtual scrolling kicks in for large tables — the grid can hold tens of thousands of rows while only ~50 live in the DOM at any moment.
The editor goes read-only above a few megabytes so assigning a huge string to a text area doesn't block the main thread. The data still loads into the table.
Lazy tree expansion builds deep nodes only as you open them.

Tip: For documents over 50 MB, expect about a second of busy cursor while DOMParser does its initial work — native parsing is the floor. Once it is parsed, sorting and search stay instant.

Is my XML uploaded anywhere?

No. The viewer is a single HTML file with no backend and no upload endpoint. Your XML is parsed and rendered by your browser's own engine — the people running the site cannot see what you paste. Full details are in the privacy policy.

Open the viewer and try it →