Go Module Proxy Scraper - Versions & Release History

Look up any Go module path and get its latest version, when that version was published, the total number of published versions, and a list of version tags, straight from the official Go module proxy. Built for dependency audits, release monitoring and checking whether a Go module is still maintained.

Why use this scraper

The Go ecosystem has no central package registry website like npm or PyPI; version and release data lives behind the Go module proxy's machine-readable endpoints (@latest, @v/list), which are built for the go tool, not for bulk human research. Checking the latest version and release history of more than a handful of modules means scripting calls to those endpoints yourself, including handling the proxy's own path-escaping rules for modules with uppercase letters.

This Actor does that for you: give it one module path or a list, and it returns the latest version, when it shipped, how many versions exist in total, and a sample of version tags for each one, all from the public proxy, no git clone and no go toolchain required.

Overview

For each Go module path, the Actor queries the official Go module proxy (proxy.golang.org) @latest and @v/list endpoints, applying the proxy's escaping rules for modules with uppercase characters in their path. It returns the latest version string, the publish time of that version, the total count of published versions, and up to the first 30 version tags. A run of 20 modules typically finishes in a few seconds, since this is plain HTTP against a JSON/text API with no browser involved.

Supported inputs

Field	Type	Required / default	Description
module	string	Optional, prefilled with github.com/gin-gonic/gin	A single Go module path
modules	array of strings	Optional	Multiple module paths in one run, duplicates removed (case insensitive)
maxItems	integer	Default 20, min 1, max 100	Maximum number of modules to process in the run

At least one module path must be supplied via module or modules, otherwise the run returns a single warning item and exits without charging.

Use cases

1. Dependency audits - check the latest version and release date of every module in a Go project's go.mod file at once, to spot dependencies that haven't been updated in a long time.
2. Release monitoring - re-run against a watchlist of modules on a schedule to catch new releases of libraries your project depends on, before go get -u would.
3. Maintenance health checks - use latestVersionTime and versionsCount together to distinguish an actively released module from one that has gone quiet, before adopting it in a new project.
4. Module popularity and activity comparison - compare the version cadence (versionsCount over time, publish gaps) of two or more competing Go libraries before choosing one.
5. Supply chain and security review input - build a list of exact module versions currently in use and their publish dates, as one input into a broader open-source dependency risk review.

How it works

1. The Actor normalizes module and modules into one deduplicated list (case insensitive) and caps it at maxItems.
2. For each module path, it applies the Go module proxy's own escaping rules (uppercase letters are escaped as ! plus the lowercase letter) before building the request path, since the proxy requires this for any module with mixed case.
3. It requests the @latest endpoint for the current version and publish time, and the @v/list endpoint for the full list of published version tags.
4. The response returns the latest version, its publish time, the total version count, and the first 30 version tags from the list.
5. A module path that the proxy cannot resolve (private module, typo, or a module that was never fetched through the public proxy) produces a row with module and an error field instead of stopping the run.

Input configuration - 3 examples

Single module:

{
  "module": "github.com/gin-gonic/gin",
  "maxItems": 1
}

Comparing a few related modules:

{
  "modules": ["github.com/gin-gonic/gin", "github.com/labstack/echo", "github.com/gofiber/fiber"],
  "maxItems": 10
}

Larger batch for a go.mod dependency audit:

{
  "modules": ["github.com/spf13/cobra", "github.com/stretchr/testify", "google.golang.org/grpc"],
  "maxItems": 50
}

Output sample

Real output from a reference run against github.com/gin-gonic/gin:

{
  "module": "github.com/gin-gonic/gin",
  "latestVersion": "v1.12.0",
  "latestVersionTime": "2026-02-28T10:10:09Z",
  "versionsCount": 28,
  "versions": [
    "v1.9.0", "v1.3.0", "v1.7.0", "v1.8.0", "v1.6.0", "v1.12.0", "v1.8.2",
    "v1.1.1", "v1.5.0", "v1.7.2", "v1.7.1", "v1.1.3", "v1.1.2", "v1.9.1"
  ],
  "scrapedAt": "2026-10-21T09:18:44.727Z"
}

A module path the proxy cannot resolve returns:

{
  "module": "example.com/not-a-real-module",
  "error": "not_found"
}

Key output fields

Field	Type	Description
module	string	Module path as requested
latestVersion	string or null	Latest version according to the proxy
latestVersionTime	string (ISO) or null	Publish time of the latest version
versionsCount	integer	Total number of versions listed by the proxy
versions	array of strings	Version tags, truncated to the first 30 entries
error	string	Present only on modules the proxy could not resolve
scrapedAt	string (ISO)	Timestamp of extraction

Pricing

Pay per event: $0.0008 per module item successfully returned ("Item scraped" event). Error and warning items are not charged. There is no separate Actor start fee. On the free Apify plan, maxItems is capped at 10 per run so you can inspect the real output format before upgrading.

What makes this richer than the competition

Compared to parseforge/go-pkg-modules-scraper and benthepythondev/go-package-search-scraper, which pull module listing data from pkg.go.dev's search and documentation pages, this Actor reads the Go module proxy's own version-of-record endpoints directly, the same source the go tool itself trusts, and returns the full version count alongside the sampled tag list in one call. That makes it a closer match for a dependency-audit workflow that cares about exact version and publish-time data rather than documentation or import-count metadata.

Notes & limitations

• Only exact module paths are supported; there is no keyword or fuzzy search across the Go module ecosystem.
• versions is truncated to the first 30 entries in the order the proxy returns them; use versionsCount for the true total when a module has more than 30 releases.
• Pseudo-versions (commit-based versions without a tagged release) and retracted versions are not filtered out or labeled separately.
• Per-version publish timestamps are only returned for the latest version; historical per-tag timestamps are not part of the output.
• README content, license, import counts and other pkg.go.dev-style documentation metadata are not returned, this Actor is scoped to version and release data only.
• A private module, or one that has never been fetched through the public Go module proxy, comes back as an error rather than a guessed result.

FAQ

Can I look up a module by a partial name or keyword? No, you need the exact module path as it appears in a go.mod file, e.g. github.com/gin-gonic/gin.

Does this work for private Go modules? No, only modules reachable through the public Go module proxy are supported.

What does versionsCount include that versions doesn't? versionsCount is the true total number of published versions; versions is capped at the first 30 tags returned by the proxy, so for modules with many releases the two numbers will differ.

How many modules can I process in one run? Up to maxItems, capped at 100 per run (10 on the free Apify plan).

Does this tell me if a module is still actively maintained? Not directly, but latestVersionTime and versionsCount together are a reasonable proxy: a module with no recent version and a small, old version list has likely gone quiet.

Is a browser needed to run this? No, it queries the Go module proxy's public endpoints directly with plain HTTP requests.

Why does the proxy need escaping rules for uppercase letters? The Go module proxy's on-disk and URL layout is case-sensitive but many filesystems and URLs are not, so any uppercase letter in a module path is encoded as an exclamation mark followed by the lowercase letter (for example GoogleCloudPlatform becomes !google!cloud!platform). The Actor applies this automatically, so you can pass module paths exactly as they appear in a go.mod file.

Can I use this to decide whether to upgrade a dependency? It gives you the inputs for that decision, the latest version and when it shipped, but it does not diff changelogs or release notes between versions; pair it with the module's own release notes for the final call.

For AI Agents & LLM Apps

This Actor is available over the Apify MCP server (mcp.apify.com) for direct use from Claude, ChatGPT or any MCP-compatible agent, and over the standard Apify API.

curl "https://api.apify.com/v2/acts/gio21~gomodule-proxy-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{"module": "github.com/gin-gonic/gin", "maxItems": 1}'

Disclaimer

This Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Google, the Go project, or any of their subsidiaries. It reads publicly available module proxy data. All trademarks mentioned are the property of their respective owners.

SEO Keywords

Go module scraper, Go module proxy API, Go package version checker, golang dependency audit tool, proxy.golang.org scraper, Go module release history.