Maven Central Scraper - 3 Lookup Modes, Version Count

Why use this scraper

Maven Central has a search UI built for a human clicking through one artifact at a time, not for checking dozens of dependencies in a single pass. Anyone auditing a JVM project's dependency tree, building a dependency-health dashboard, or watching a short list of libraries for new releases ends up opening the same search page over and over by hand. This actor turns that into a single structured call: give it a groupId and artifactId, a groupId alone, or a free-text query, and get back the latest version, packaging type, last-publish date and how many versions have ever been published, for as many artifacts as you need in one run.

Overview

The actor queries Maven Central's public search index for whatever you give it in groupId, artifactId or query, then makes one additional request per matched artifact to count its published versions. A lookup of a handful of known artifacts by exact groupId + artifactId finishes in a few seconds; a broader free-text query against maxItems of 100 takes longer because of the extra per-artifact version-count request. Pricing is pay-per-result: you are charged only for the artifact items actually returned, nothing for a run that finds no match.

Supported inputs

• Exact lookup (groupId + artifactId) - the most precise mode, for when you already know exactly which artifact you want, e.g. com.google.guava / guava.
• Group-wide lookup (groupId alone) - returns every artifact Maven Central indexes under that group, for auditing everything one organization publishes.
• Free-text search (query) - a plain search string used instead of groupId/artifactId, for when you only know a library's common name (for example jackson-databind) and want to find the matching coordinates.
• Max artifacts (maxItems) - how many artifacts to return, up to 100. groupId and artifactId together take precedence over query when both are supplied.

Use cases

• Dependency audits. Check the latest version and packaging of every third-party library a project declares, in one batch instead of one browser tab per dependency.
• Release monitoring. Schedule a run against a short list of artifacts your team depends on and compare latestVersion and timestamp against the last run to catch new releases.
• Supply-chain and dependency-health tooling. Feed versionCount and timestamp into a scoring model that flags dependencies that have gone stale or that are unusually young.
• Coordinate discovery. Use free-text query to find the exact groupId/artifactId pair for a library you only know by its common name, before wiring it into a build file.
• Build-tool and IDE plugin backends. Power an autocomplete or dependency-picker feature by resolving a typed library name to real Maven coordinates on demand.
• License and compliance pre-screening. Pull the full artifact list for a vendor's or open-source project's groupId as a first pass before a deeper license review, so the review starts from a complete list of what that group actually publishes instead of a manually assembled one.
• Onboarding new engineers. Give a new team member a single call that resolves every dependency coordinate the team cares about, instead of pointing them at a dozen separate search.maven.org tabs to look up by hand.

How it works

The actor calls Maven Central's own public search API with whatever combination of groupId, artifactId or query you provide, the same index behind the search box on search.maven.org, so results match what you would see there. For each matched artifact it then makes one more request to the same index to count how many versions have ever been published for that groupId/artifactId pair; version counting is treated as best effort and comes back null on failure rather than blocking the rest of the run.

Input configuration

Exact artifact lookup:

{ "groupId": "com.google.guava", "artifactId": "guava", "maxItems": 20 }

Free-text search by library name:

{ "query": "jackson-databind", "maxItems": 10 }

Every artifact published under one group:

{ "groupId": "org.springframework.boot", "maxItems": 100 }

Output sample

Real artifacts from a production run:

{
  "groupId": "com.google.guava",
  "artifactId": "guava",
  "latestVersion": "33.4.8-jre",
  "packaging": "bundle",
  "timestamp": "2025-04-14T17:25:22.422Z",
  "versionCount": 150,
  "scrapedAt": "2026-10-13T09:22:30.867Z"
}

{
  "groupId": "io.github.errantfiddle",
  "artifactId": "jackson-databind",
  "latestVersion": "2.16.0",
  "packaging": "jar",
  "timestamp": "2023-08-30T05:24:10.000Z",
  "versionCount": 1,
  "scrapedAt": "2026-10-13T09:22:45.035Z"
}

Key output fields

Field	Type	Description
groupId	string	Maven groupId
artifactId	string	Maven artifactId
latestVersion	string	Latest version reported by Maven Central, null if unavailable
packaging	string	Packaging type, e.g. jar, bundle, pom
timestamp	string	ISO timestamp of the latest version's upload
versionCount	number	Total number of versions ever published for this artifact, null on a counting failure
scrapedAt	string	ISO timestamp of the extraction

A run that finds nothing pushes a single warning item instead of a result row, and a request failure pushes an error item, so a filtered batch lookup never silently returns an empty dataset without telling you why.

Pricing

Pay per result:

Event	Price
Item scraped	$0.001

Example: 50 artifacts cost about $0.05. Warning and error items are never charged.

What makes this richer than the competition

Two other Store listings cover Maven Central lookups with the same active usage as this actor today. ninhothedev/maven-central-scraper ("Maven Central Scraper - Java & JVM Artifacts, Versions & Deps", 2 users/30 days) prices at $0.00005 per actor start plus $0.0005 per result, below this actor's $0.001 per item. brunofin/maven-central-stats ("Maven Central Stats", 2 users/30 days) charges a flat $0.0005 actor-start fee with no per-result pricing disclosed. What this actor adds in exchange for its higher per-item price is the versionCount field computed for every artifact in the same run, not just the latest version, so you can tell a library that has published 150 versions from one that has published a single release without a second lookup, plus three distinct lookup modes (exact coordinates, whole-group, and free text) behind one input schema.

Notes & limitations

• versionCount is best-effort: if Maven Central's index does not answer the follow-up count request, the field comes back null rather than a guessed number.
• Dependency lists, POM metadata (license, developers, SCM URL) and download counts are not returned, only the fields listed above.
• A free-text query returns whatever Maven Central's own search ranking surfaces first; there is no custom sort order.
• groupId and artifactId together always take precedence over query when both are present in the input.
• A group-wide lookup (groupId alone, no artifactId) can return a large number of artifacts for organizations that publish many modules; set maxItems to a sensible cap rather than defaulting to the maximum when you only need a subset.
• The actor reads Maven Central's own public search index; it does not parse POM files directly, so fields that only live inside a POM (dependencies, license text, developer list, SCM URL) are out of scope for this version.
• This actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Sonatype or Maven Central.

FAQ

What if I only know the library's name, not its groupId? Use query with the library name, e.g. "jackson-databind"; the actor returns every matching artifact it finds so you can pick the right coordinates.

Can I list every artifact one organization publishes? Yes, set groupId alone without artifactId; the actor returns every artifact Maven Central indexes under that group, up to maxItems.

Why is versionCount sometimes null? The version count comes from a second request per artifact to Maven Central's own index; when that request fails the actor returns null rather than inventing a number.

Can I use this to check if a dependency is up to date? Yes. Compare latestVersion and timestamp against the version your project currently pins; a large gap between timestamp and today is a useful signal even without a full semantic-version comparison.

Does a run with no matches get charged? No. A run with no matches pushes a single warning item and you are only charged for actual result items returned.

Is this affiliated with Maven Central or Sonatype? No. This is an independent tool for looking up publicly available package metadata.

For AI Agents & LLM Apps

This actor is available over the Apify MCP server (mcp.apify.com) for any MCP-compatible agent to call as a tool with a groupId/artifactId or free-text query as input, and can be called synchronously from any backend via run-sync-get-dataset-items:

curl "https://api.apify.com/v2/acts/gio21~maven-central-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -X POST -H "Content-Type: application/json" \
  -d '{"groupId": "com.google.guava", "artifactId": "guava", "maxItems": 20}'

Disclaimer

This actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Sonatype, Maven Central or any of its subsidiaries. All trademarks mentioned are the property of their respective owners.

SEO Keywords

Maven Central scraper, Maven artifact API, Java dependency lookup, JVM package metadata API, Maven version checker.