pom.xml Viewer

A Maven pom.xml is just XML — so you can open one in Pretty JSON & XML and read every dependency, plugin, and property as a sortable table or a foldable tree. No Maven install, no upload, no waiting on an IDE to index. Below is a sample POM you can load with one click, plus how the viewer makes a dense build file readable.

The sample

A trimmed but realistic pom.xml — project coordinates, properties, a handful of dependencies, and one build plugin:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.prettyjsonxml</groupId>
  <artifactId>sample-service</artifactId>
  <version>1.4.2</version>
  <packaging>jar</packaging>

  <properties>
    <java.version>17</java.version>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>

  <dependencies>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
      <version>3.2.5</version>
    </dependency>
    <dependency>
      <groupId>org.postgresql</groupId>
      <artifactId>postgresql</artifactId>
      <version>42.7.3</version>
      <scope>runtime</scope>
    </dependency>
    <dependency>
      <groupId>org.junit.jupiter</groupId>
      <artifactId>junit-jupiter</artifactId>
      <version>5.10.2</version>
      <scope>test</scope>
    </dependency>
  </dependencies>

  <build>
    <plugins>
      <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
      </plugin>
    </plugins>
  </build>
</project>

What is a pom.xml?

pom.xml is the Project Object Model — the single file Apache Maven reads to build a Java project. It declares the project's coordinates (groupId, artifactId, version), the libraries it depends on, the plugins that run during the build, and properties that parameterize the whole thing. One file describes the entire build.

The structure is consistent across nearly every Java repository:

• Coordinates — groupId, artifactId, version, and packaging identify the artifact this project produces
• Properties — reusable values like java.version or a shared library version, referenced elsewhere as ${...}
• Dependencies — a list of <dependency> blocks, each with its own coordinates and an optional scope (compile, runtime, test, provided)
• Build / plugins — the plugins Maven runs through the lifecycle, such as the compiler, Surefire, or the Spring Boot packager

Why view a pom.xml as a table?

A real-world POM can run to hundreds of lines, and the part you usually care about — the dependency list — is buried in repetitive, deeply indented blocks. Scanning that as raw XML is slow and error-prone. As a table, the same data becomes something you can actually reason about:

• Sort by Artifact ID to find a library instantly, or by Scope to separate test-only deps from runtime
• Search for a group like org.springframework to see everything from one vendor at once
• Spot duplicates or missing versions — an empty Version cell jumps out when the rest of the column is filled
• Compare two POMs side by side when reconciling versions across modules

How Pretty JSON & XML handles a POM

When you paste a pom.xml, the viewer:

1. Parses the XML and finds <dependency> as the repeated element under <dependencies>
2. Renders each dependency as a row, picking groupId, artifactId, version, and scope as columns
3. Surfaces the single-value project fields — coordinates, packaging, and properties — above the table as context, so they aren't lost
4. Keeps <build> and its plugins as a foldable subtree you can open when you need it

Click any row to expand the full <dependency> block, including less common fields like <optional>, <type>, or nested <exclusions>. Prefer the raw shape? Switch to Tree view for the whole document with every element foldable.

Other build files work too

Anything XML-shaped renders the same way. A parent POM, a multi-module aggregator with a <modules> list, a settings.xml, or an Ivy file all parse cleanly — repeated elements become rows, single values become context. If it is valid XML, you can read it here without leaving the browser.

Open the viewer and paste your own pom.xml →