📦 Maven Helper

Convert between Maven groupId:artifactId:version coordinates, pom.xml dependency blocks, and Gradle snippets. Runs entirely in your browser.

Waiting for input…

INPUT — GAV OR XML

PARSED COORDINATE

groupId—

artifactId—

version—

packaging / type—

classifier—

scope—

Generated output

📦

Paste a GAV coordinate or a <dependency> block above to generate pom.xml, GAV, and Gradle output.

About the Maven Helper

Every Java and Kotlin build tool identifies a library by three coordinates: the groupId (the organisation, e.g. org.springframework.boot), the artifactId (the module, e.g. spring-boot-starter-web) and the version. Maven writes these as a verbose <dependency> XML block, while the Maven CLI, Gradle, and most documentation use the compact groupId:artifactId:version (GAV) shorthand. This tool converts freely between the two — plus generates the Gradle snippet — so you can copy a dependency from one project into another regardless of which format you started with.

Everything runs locally in your browser. Nothing you paste is ever sent to a server, which makes it safe for internal or private artifact coordinates.

How to use it

Paste your input on the left — either a GAV string like com.google.guava:guava:33.2.1-jre or a full <dependency> XML block. The tool auto-detects which one you pasted.
Check the parsed coordinate on the right. Each segment — groupId, artifactId, version, and optional packaging, classifier and scope — is broken out into its own field.
Copy any output — GAV string, pom.xml block, or Gradle snippet (Groovy or Kotlin DSL) — with the copy button on each block.

Features

🔁 Bidirectional

Paste XML to get a GAV string, or paste a GAV string to get a ready-to-paste pom.xml block.

🐘 Gradle output

Generates both Groovy and Kotlin DSL dependency lines, mapping Maven scope to the right Gradle configuration.

🧩 Full coordinates

Supports optional packaging/type, classifier, and scope — not just the basic three segments.

🚦 Validation

Flags missing segments and invalid characters inline before you copy anything broken into your build file.

🔒 100% client-side

All parsing happens in your browser. Private and internal coordinates never leave your machine.

📋 One-click copy

Every generated block has its own copy button, so you grab exactly the format you need.

Frequently Asked Questions

What is a GAV coordinate?

GAV stands for groupId, artifactId, version — the three coordinates that uniquely identify a Maven artifact. Written compactly they look like org.springframework.boot:spring-boot-starter-web:3.3.2. Maven also supports longer forms that add packaging and classifier: groupId:artifactId:packaging:classifier:version.

How does Maven scope map to Gradle?

This tool maps Maven's <scope> to the closest Gradle configuration: compile (default) → implementation, test → testImplementation, provided → compileOnly, and runtime → runtimeOnly. If no scope is present, it defaults to implementation.

Can I convert a dependency without a version?

A version is required to generate valid output, because pom.xml and Gradle both need one (unless it is managed by a BOM or dependencyManagement block). If you omit it, the tool flags a 'Missing version' error rather than producing a broken snippet.

Does it support property placeholders like ${spring.version}?

Yes. Version fields may contain ${...} placeholders, so you can convert dependencies that reference a managed version property without the tool rejecting them.

Is my data sent anywhere?

No. All parsing and conversion happen entirely in your browser using JavaScript. Nothing you paste is transmitted or stored, so it is safe to use with private or internal artifact coordinates.

Complete guide to Maven coordinates, pom.xml and Gradle dependencies

Every Java dependency is identified by a coordinate: a groupId that names the organisation, an artifactId that names the library, and a version. Written as a single string that is com.google.guava:guava:33.2.1-jre, usually called a GAV. Written in a pom.xml it becomes a multi-line <dependency> block, and in a Gradle build file it becomes something different again.

Those three formats carry identical information but are needed in different places. A README or a Stack Overflow answer gives you a GAV string; your build file needs XML. A Maven project you are migrating has XML; your new Gradle build needs a implementation line. Converting by hand is trivial but tedious, and it is easy to drop a segment or misplace a scope while doing it.

This tool converts in both directions. Paste a GAV coordinate and get a ready-to-paste pom.xml block plus Gradle lines in both the Groovy and Kotlin DSL. Paste a <dependency> block and get the GAV string back. It handles more than the basic three segments, so optional packaging, classifier and scope survive the round trip.

Input is validated as you type. Missing segments and invalid characters are flagged inline, so you find out before you paste something broken into a build file and wait for Maven to tell you. Everything runs in your browser, which matters when the coordinates belong to a private or internal artifact repository.

How it works

A coordinate string is split on colons and interpreted by segment count, following the same rules Maven uses. Three segments are groupId:artifactId:version. Four are groupId:artifactId:packaging:version. Five are groupId:artifactId:packaging:classifier:version. This is why a coordinate with a classifier cannot be read correctly by simply splitting into three parts.

XML input is parsed by reading the groupId, artifactId, version, type, classifier and scope tags out of the dependency block, so surrounding whitespace, comments and attribute ordering do not matter. The parser does not require a full valid pom, only the dependency element itself.

Gradle output maps the Maven scope to the matching Gradle configuration rather than copying it verbatim, because the vocabularies differ. Maven compile becomes implementation, provided becomes compileOnly, runtime becomes runtimeOnly, and test becomes testImplementation. Both the Groovy DSL and the Kotlin DSL forms are produced, since the quoting and syntax differ between them.

Validation checks that the required segments are present and that each contains only characters legal in a Maven coordinate. Errors are reported as readable messages rather than a generic failure, so you can see which segment is at fault.

Common uses

Convert a GAV string from a README, blog post or Stack Overflow answer into a pom.xml block you can paste straight into a project.
Migrate a Maven project to Gradle by turning existing dependency blocks into implementation and testImplementation lines.
Translate between the Groovy DSL and Kotlin DSL when moving a Gradle build to build.gradle.kts.
Check that a coordinate with a classifier, such as a sources or javadoc artifact, is written with the segments in the right order.
Produce a clean GAV string to share in a ticket, chat message or dependency report without pasting a block of XML.
Verify that a hand-written coordinate is syntactically valid before committing it to a build file.
Convert coordinates for internal or private artifacts without sending them to an external service.

Before you rely on the result

The tool validates the shape of a coordinate, not its existence. A syntactically perfect GAV can still fail to resolve because the artifact is not in any repository you have configured, or the version does not exist. Confirm against Maven Central or your internal repository before relying on it.
Maven scope and Gradle configuration are related but not equivalent. The mapping produced here is the conventional one, but a project with custom configurations, platform BOMs or feature variants may need something different.
A dependency copied without its scope defaults to compile in Maven and implementation in Gradle. If the original was test or provided, dropping the scope silently ships a test or container-supplied library into your production artifact.
Version ranges and property placeholders such as ${spring.version} are treated as literal text. They are preserved, but the tool cannot resolve what they evaluate to.
Transitive dependencies are not shown. A single coordinate can pull in dozens of others, and conflicts between them are resolved by Maven or Gradle at build time. Use mvn dependency:tree or gradle dependencies to see the real graph.
Exclusions inside a dependency block are not part of the coordinate and are not carried across. If the original dependency had exclusions, re-add them after converting.
For a multi-module project, confirm whether the dependency belongs in the parent dependencyManagement section rather than directly in a module, so versions stay consistent across modules.