How to Scrape Docker Hub: Search, Repos & Tags in 2026

Docker Hub hosts over 10 million container repositories, and every one of them carries metadata you might want in bulk: pull counts, star counts, official status, tag lists, image digests. The problem is that Docker Hub gives you a web UI and a per-request API, but no bulk export. If you want to audit every image a vendor publishes, rank container images by popularity in a category, or pull the full tag history of a base image, you’re stuck paginating a cursor-based API by hand and stitching the pages together. This guide covers how the Docker Hub API works and how to extract clean, structured image data across four different query modes.

What’s worth extracting

The actor outputs one row per repository (in search, namespace and detail modes) or one row per tag (in tags mode). The fields break into two groups.

Repository fields:

• name, namespace and fullName — the repo name (postgres), its owner (library, bitnami) and the full slug (library/postgres).
• description — the short description shown on Docker Hub.
• isOfficial — "true" for Docker official images.
• isAutomated — "true" if the image builds automatically from a VCS.
• isPrivate — "true" for private repos (only visible if accessible).
• starCount and pullCount — popularity signals; pull count is the total lifetime pulls.
• lastUpdated — ISO 8601 timestamp of the last push.
• repoUrl — the direct Docker Hub URL.

Tag fields (tags mode only):

• tagName — the tag itself (latest, 17-alpine).
• tagDigest — the SHA256 digest of the tag’s primary image.
• tagLastUpdated — when that tag was last pushed.
• tagSize — combined image size in bytes.
• architectures — comma-separated platform list (e.g. amd64, arm64).

That’s 15+ fields per repo, enough to benchmark image popularity, track a vendor’s full catalog, or correlate digests against a vulnerability database.

How the Docker Hub API actually works

The actor connects directly to Docker Hub’s official public REST API at hub.docker.com/v2/. This is the same API the Docker Hub website uses, and critically it’s fully public and keyless — no Docker account, no token, no login. It paginates cursor-style, returning up to 100 items per request, and the actor walks every page automatically with retries and exponential backoff.

There are four modes, each hitting a different part of the API. Search discovers images by keyword across the full 10M+ index:

{
  "mode": "search",
  "query": "postgres",
  "maxResults": 200
}

namespaceRepos crawls every public repository owned by a user or organization — useful for auditing a vendor’s entire offering:

{
  "mode": "namespaceRepos",
  "namespace": "bitnami",
  "maxResults": 500
}

repoDetail fetches full metadata for a known list of images, which is ideal for enriching the contents of a lockfile or Docker Compose:

{
  "mode": "repoDetail",
  "namespace": "library",
  "repos": ["postgres", "redis", "nginx", "node", "python"]
}

And tags retrieves every tag for one or more repos, with digest and architecture info:

{
  "mode": "tags",
  "namespace": "library",
  "repos": ["postgres"],
  "maxResults": 1000
}

The library namespace is worth knowing about: it holds all 179 Docker official images, so namespaceRepos with namespace: "library" gives you the complete official catalog in one run.

▶ Open the Docker Hub Scraper on Apify — search, crawl a namespace, fetch repo detail or list every tag, all through the public v2 API. No Docker account, no token, no login. Export to CSV, JSON, Excel or XML.

The access reality

Docker Hub’s API is designed for programmatic access, so this is a friendly target compared to anti-bot-defended sites. The realities to plan around are throughput and mode-specific field coverage.

• Datacenter proxies are sufficient. Docker Hub does not block datacenter IPs, so residential proxies are unnecessary — which keeps cost down. The actor uses Apify datacenter proxies by default.
• The per-run ceiling is 10,000 results. maxResults (default 200) caps a run anywhere from 1 to 10,000. For larger datasets, run multiple times across different queries or namespace segments.
• Search returns fewer fields than detail. This is the biggest gotcha. The search endpoint is lean — fields like lastUpdated come back empty for search results. If you need full metadata, take the repo names from a search run and re-run them through mode: "repoDetail" to enrich. A common two-step workflow is: search to discover the namespaces, then namespaceRepos (or repoDetail) to pull the complete data.
• Namespaces are case-sensitive. Docker Hub uses lowercase namespace slugs — match exactly (bitnami, not Bitnami), or you’ll get zero results.

Speed is not a concern: each page of 100 results takes roughly 1–3 seconds, a 200-result search finishes in under 30 seconds, and a 10,000-result namespace crawl typically runs 5–15 minutes.

Example output

One repository row from a search or detail run:

{
  "name": "postgres",
  "namespace": "library",
  "fullName": "library/postgres",
  "description": "The PostgreSQL object-relational database system provides reliability and data integrity.",
  "isOfficial": "true",
  "isAutomated": "false",
  "isPrivate": "false",
  "starCount": "14955",
  "pullCount": "10943948884",
  "lastUpdated": "2026-07-08T13:09:12.432256Z",
  "repoUrl": "https://hub.docker.com/_/postgres"
}

In tags mode the same row shape is populated with tagName, tagDigest, tagLastUpdated, tagSize and architectures instead.

Typical use cases

• Image discovery — search a category like “machine learning” or “rust” to find the most-pulled container images before choosing a base image.
• Org / vendor auditing — list every repository published by bitnami, grafana or linuxserver to track their full offering and catch new releases.
• CI/CD due diligence — fetch the full tag history for library/node or library/python to understand release cadence and verify digest integrity.
• Competitive analysis — compare pull counts and star counts across competing images (postgres vs mysql vs mariadb) to gauge ecosystem adoption.
• Security scanning — extract image digests for every tag of a repo, then correlate them against CVE databases or an internal scanner.
• Ecosystem trend datasets — analysts building longitudinal datasets of which images are rising, by star and pull volume over time.

Build-it-yourself vs. managed

The v2 API is public, so writing your own client is realistic. What you actually end up building:

• Cursor pagination — walking Docker Hub’s cursor-based pages 100 at a time until exhaustion, with retries and backoff on transient HTTP errors.
• Four separate code paths — search, namespace crawl, detail fetch and tag listing each hit a different endpoint with a different response shape.
• Field normalization — flattening the responses into a single consistent row schema across all four modes, and handling the fact that search returns sparse fields.
• Export plumbing to get the results into CSV or a spreadsheet.

It’s a day or two of work, and Docker Hub’s public API is stable enough that maintenance is light. The managed actor already carries all four modes and runs on pay-per-result pricing — a fraction of a cent per row — so even a 10,000-row namespace crawl costs a few dollars, with no proxy bill because datacenter IPs work fine here.

Common pitfalls

Specifics that will bite you on Docker Hub:

• Search results are intentionally sparse. Don’t treat an empty lastUpdated from a search run as missing data — re-run those repos through repoDetail to fill it in.
• Namespaces are lowercase and exact. A capitalization mismatch returns zero rows, not an error. Verify the slug on hub.docker.com if a namespace crawl comes back empty.
• Numeric fields arrive as strings. pullCount, starCount and tagSize are strings ("10943948884") — cast them before doing math or sorting numerically.
• Big repos have huge tag lists. Images like library/node carry 1,000+ tags. Set maxResults high enough in tags mode or you’ll silently miss versions.
• Private repos are invisible. The actor only reads public endpoints — private repositories require authentication and won’t appear.
• Full layer manifests aren’t here. Tags mode gives you the digest of the primary architecture; deep layer/manifest inspection needs the separate Docker Registry v2 API.

Wrapping up

Docker Hub is one of the friendlier bulk targets out there — a public, keyless API that just needs correct pagination and a bit of mode-aware field handling. If you need image data once and enjoy the plumbing, build a client against hub.docker.com/v2/. If you want search, namespace crawls, repo detail and tag listings in one tool, exported straight to a spreadsheet, the managed actor does it today.

▶ Run the Docker Hub Scraper on Apify — one run returns up to 10,000 repos or tags with pull counts, stars, official status and digests across four query modes. No Docker account, no token, no login. Export to CSV, JSON, Excel or XML. Start on Apify’s free monthly credit.