# Docker Hub Scraper — Search, Repos & Tags (`logiover/docker-hub-scraper`) Actor

Scrape Docker Hub by keyword search, namespace, or repo detail. Extract image name, pull count, star count, tags, description, official status. No API key, no login required.

- **URL**: https://apify.com/logiover/docker-hub-scraper.md
- **Developed by:** [Logiover](https://apify.com/logiover) (community)
- **Categories:** Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Docker Hub Scraper — Search, Namespace Repos, Details & Tags

Scrape Docker Hub at scale: search container images by keyword, list all repos in any namespace/org, fetch full repo metadata, and extract complete tag lists — no API key, no login required.

### What does Docker Hub Scraper do?

Docker Hub Scraper connects directly to Docker Hub's official public REST API (`hub.docker.com/v2/`) to extract container image metadata at scale. It supports four distinct modes: **search** (keyword-based discovery across Docker Hub's full index of 10+ million images), **namespaceRepos** (crawl every repository owned by a user or organization), **repoDetail** (fetch comprehensive metadata for specific repos), and **tags** (retrieve all available tags for any image, including architecture and digest info).

The actor paginates automatically through all available results using Docker Hub's cursor-based API, collecting up to 100 items per request. It handles retries with exponential backoff, supports Apify datacenter proxies for high throughput, and outputs clean structured rows — one per repository or tag. Because Docker Hub's `/v2/` API is fully public and keyless, anyone can run this actor immediately without creating Docker credentials or configuring auth.

### Who is it for?

- **DevOps engineers** who want to audit which images their team relies on, check pull counts, and verify official image freshness.
- **Security researchers** scanning Docker Hub for outdated or vulnerable base images across large namespaces.
- **Data analysts** building datasets of container ecosystem trends — which images are rising, star counts, pull volumes.
- **Platform teams** monitoring a vendor namespace (e.g. bitnami, grafana, nginx) for new releases and tag changes.
- **Developers and architects** benchmarking image popularity before choosing a base image for their stack.

### Use cases

- **Image discovery**: Search "machine learning" or "rust" to find the most-pulled container images in any technology category.
- **Org/vendor auditing**: List all 200+ repositories published by `bitnami` or `grafana` to track their full offering.
- **CI/CD due diligence**: Fetch 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 for competing database images (postgres vs mysql vs mariadb).
- **Security scanning**: Extract image digests for all tags of a repo to correlate against CVE databases or internal scanners.

### Why use Docker Hub Scraper?

- **Keyless**: No Docker account, no API token, no login — works out of the box for anyone.
- **15+ fields per repo**: name, namespace, description, star count, pull count, official status, automation flag, last updated timestamp, and more.
- **Bulk pagination**: Fetches up to 10,000 results per run with automatic page-by-page iteration.
- **Four modes in one**: switch between search, org crawl, detail fetch, and tag listing without switching actors.
- **Export ready**: Download results as CSV, JSON, Excel, XML via Apify's built-in dataset export.
- **Pay-per-result**: Charged only for what you actually scrape — cost-efficient for small and large runs alike.

### What data can you extract?

The actor outputs one row per repository (in search/namespaceRepos/repoDetail modes) or one row per tag (in tags mode).

| Field | Type | Description |
|---|---|---|
| `name` | String | Repository name (e.g. `postgres`) |
| `namespace` | String | Owner namespace or org (e.g. `library`, `bitnami`) |
| `fullName` | String | Full slug: `namespace/name` |
| `description` | String | Short description shown on Docker Hub |
| `isOfficial` | String | `"true"` if Docker official image |
| `isAutomated` | String | `"true"` if built automatically from a VCS |
| `isPrivate` | String | `"true"` if private repo (only visible if accessible) |
| `starCount` | String | Number of stars |
| `pullCount` | String | Total lifetime pull count |
| `lastUpdated` | String | ISO 8601 timestamp of last push |
| `repoUrl` | String | Direct Docker Hub URL |
| `tagName` | String | Tag name (tags mode only, e.g. `latest`, `17-alpine`) |
| `tagDigest` | String | SHA256 digest of tag's primary image |
| `tagLastUpdated` | String | When this tag was last pushed |
| `tagSize` | String | Combined image size in bytes |
| `architectures` | String | Comma-separated platform list (e.g. `amd64, arm64`) |

**Sample JSON output (search/repo mode):**

```json
{
  "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",
  "tagName": "",
  "tagDigest": "",
  "tagLastUpdated": "",
  "tagSize": "",
  "architectures": ""
}
```

### How to use

#### Option A — Search images by keyword

Use mode `search` to find all Docker Hub images matching a term.

1. Open the actor and set **Mode** to `search`.
2. Enter your **Search Query** (e.g. `"nginx"`, `"pytorch"`, `"kafka"`).
3. Set **Max Results** (default 200, up to 10,000).
4. Click **Start**.

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

#### Option B — List all repos in a namespace

Use mode `namespaceRepos` to crawl every public repository under a user or organization.

1. Set **Mode** to `namespaceRepos`.
2. Set **Namespace** to the Docker Hub username or org (e.g. `bitnami`, `grafana`, `library`).
3. Set **Max Results** as needed.

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

#### Option C — Fetch detail for specific repos

Use mode `repoDetail` to pull full metadata for a known list of images.

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

#### Option D — Extract all tags for a repo

Use mode `tags` to get every available tag (version, digest, architecture) for one or more images.

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

### Input parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `mode` | String | `"search"` | Operation mode: `search`, `namespaceRepos`, `repoDetail`, `tags` |
| `query` | String | — | Search keyword (required for mode=search) |
| `namespace` | String | — | Docker Hub username/org (required for namespaceRepos, repoDetail, tags) |
| `repos` | Array | `[]` | List of repo names (required for repoDetail and tags) |
| `maxResults` | Integer | `200` | Maximum number of results to return (1–10,000) |
| `proxy` | Object | datacenter | Apify proxy configuration |

**Full input example:**

```json
{
  "mode": "search",
  "query": "machine learning",
  "maxResults": 500,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": []
  }
}
```

### Output example

```json
{
  "name": "redis",
  "namespace": "library",
  "fullName": "library/redis",
  "description": "Redis is an open source key-value store that functions as a data structure server.",
  "isOfficial": "true",
  "isAutomated": "false",
  "isPrivate": "false",
  "starCount": "12847",
  "pullCount": "4912033571",
  "lastUpdated": "2026-07-05T08:22:10.123456Z",
  "repoUrl": "https://hub.docker.com/_/redis",
  "tagName": "",
  "tagDigest": "",
  "tagLastUpdated": "",
  "tagSize": "",
  "architectures": ""
}
```

### Tips for best results

- **Use broad search terms first**: Start with a category keyword (`"database"`, `"monitoring"`) to discover what's available, then narrow down.
- **Set maxResults conservatively**: A limit of 200–500 covers most research needs; increase only if you need exhaustive datasets.
- **Combine modes**: Run search first to find namespaces, then use namespaceRepos to crawl them fully.
- **Official images**: The `library` namespace holds all Docker official images — use `namespaceRepos` with `namespace: "library"` to get all 179 of them.
- **Tag crawling**: Large images like `library/node` have 1,000+ tags. Set maxResults high enough to capture all versions.
- **Datacenter proxies are sufficient**: Docker Hub does not block datacenter IPs; residential proxies are unnecessary.
- **Export to CSV for spreadsheet analysis**: After the run, use Apify's dataset export button to download CSV and open in Google Sheets or Excel.
- **Schedule regular runs**: Use Apify Scheduler to track pull count trends or catch new tag releases weekly.
- **Use the repoDetail mode for enrichment**: If you have a list of known images (from a lockfile or Docker Compose), feed them directly with mode=repoDetail for quick bulk enrichment.
- **Namespaces are case-sensitive**: Docker Hub uses lowercase namespace slugs; match exactly (e.g. `bitnami` not `Bitnami`).

### Integrations

Docker Hub Scraper integrates with any tool that connects to Apify datasets:

- **Google Sheets**: Use the [Google Sheets integration](https://apify.com/integrations/google-sheets) to automatically sync results to a spreadsheet.
- **Slack**: Send notifications when new results appear via the [Slack webhook integration](https://apify.com/integrations/slack).
- **Zapier**: Connect to 5,000+ apps via Zapier — trigger a workflow whenever a run completes.
- **Make (Integromat)**: Build automation pipelines that process Docker Hub data and push it to databases or CRMs.
- **Webhooks**: Configure Apify webhooks to POST run results to your own backend as soon as data is ready.
- **Scheduler**: Run automatically on a daily or weekly schedule to monitor image updates without manual intervention.

### API usage

**cURL:**

```bash
curl -X POST "https://api.apify.com/v2/acts/logiover~docker-hub-scraper/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mode":"search","query":"postgres","maxResults":200}'
```

**Node.js (Apify client):**

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('logiover/docker-hub-scraper').call({
  mode: 'search',
  query: 'postgres',
  maxResults: 200,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

**Python:**

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("logiover/docker-hub-scraper").call(run_input={
    "mode": "search",
    "query": "postgres",
    "maxResults": 200,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

### Use with AI agents (MCP)

Docker Hub Scraper is compatible with the [Apify MCP Server](https://apify.com/apify/mcp-server), which exposes all actors as tools to AI agents. Connect it to Claude, GPT-4, or any MCP-compatible agent and ask:

> "Search Docker Hub for all official machine learning images, get their pull counts and last-updated dates, and give me a ranked table."

The agent will call Docker Hub Scraper automatically and process the results in context.

### FAQ

#### Does this actor require a Docker Hub account or API key?

No. Docker Hub's public `/v2/` API is fully open. No account, no token, no login is needed to run this actor.

#### How many images does Docker Hub have?

Docker Hub hosts over 10 million repositories as of 2026. The search API indexes all public images; namespace crawling covers the full catalog of any org.

#### What is the maximum number of results I can get in one run?

Up to 10,000 (configurable via `maxResults`). For larger datasets, run multiple times with different queries or namespace segments.

#### Why am I getting zero results?

- For `mode=search`: check that your `query` field is not empty and that the term exists on Docker Hub.
- For `mode=namespaceRepos`: verify the namespace exists and is spelled correctly (lowercase).
- For `mode=tags`: confirm the namespace and repo name are correct.
- Check the actor logs for HTTP errors; retry on transient failures.

#### Some fields are empty — is that normal?

Yes. The search endpoint returns fewer fields than the detail endpoint (e.g. `lastUpdated` is empty for search results). Use `mode=repoDetail` to enrich specific repos with full metadata.

#### How do I export results to Excel?

After the run, open the **Dataset** tab, click **Export** and choose **Excel** or **CSV**. Results are also available via the Apify API in JSON format.

#### How fast does it run?

Each page of 100 results takes roughly 1–3 seconds. A 200-result search run finishes in under 30 seconds. A 10,000-result namespace crawl typically takes 5–15 minutes.

#### Is it legal to scrape Docker Hub?

Yes. Docker Hub's public API is designed for programmatic access. The data extracted (image names, descriptions, pull counts) is publicly visible to anyone visiting hub.docker.com. This actor only reads public endpoints and does not require authentication or bypass any security measures.

#### How often is Docker Hub data updated?

Pull counts and star counts are near-real-time. Tag pushes appear within minutes of a new image push. Run the actor on a schedule to track changes over time.

#### Which namespaces are most useful to crawl?

`library` (Docker official images, 179 repos), `bitnami` (production-ready app images), `grafana` (monitoring stack), `linuxserver` (home server images), and major cloud vendor namespaces like `amazon`, `google`, `microsoft`.

#### Does this work for private repositories?

No. The actor only accesses public Docker Hub API endpoints. Private repositories are not accessible without authentication.

#### Can I get image layer digests?

Digests are available in tags mode — each tag includes the SHA256 digest for its primary architecture. Full manifest/layer details would require the Docker Registry API (v2), which is separate from Docker Hub's web API.

### Is it legal?

Docker Hub Scraper accesses only the public, unauthenticated endpoints of Docker Hub's official REST API (`hub.docker.com/v2/`). All data extracted — repository names, descriptions, pull counts, star counts, tag lists — is freely and publicly visible to anyone on hub.docker.com without logging in. This actor does not bypass authentication, circumvent rate limits aggressively, or access any private or user-specific data. Use of this actor is subject to Docker Hub's Terms of Service and the Apify platform Terms of Service. The operator is solely responsible for ensuring their use complies with applicable laws and the terms of the data source.

### Related scrapers

- [GitHub Scraper](https://apify.com/logiover/github-scraper) — scrape GitHub repos, stars, contributors, and issues.
- [NPM Package Scraper](https://apify.com/logiover/npm-registry-scraper) — extract NPM registry package metadata and download stats.
- [Tech Stack Detector](https://apify.com/logiover/tech-stack-detector) — detect frameworks, CMSes, and infrastructure tech for any website.
- [CVE Advisory Scraper](https://apify.com/logiover/cve-advisory-scraper) — pull CVE data from NVD and OSV for security monitoring pipelines.

### 📝 Changelog

#### 2026-08-01

- Completed the August 2026 full health check: verified empty/programmatic default, Console UI default, and two source-informed alternative inputs on Apify.
- Confirmed successful live execution, non-empty structured output, dataset-field/type integrity, and logical sample quality within the 5-minute quality window.
- Declared 16 dataset fields from typed live cloud samples so the output contract is no longer an empty placeholder.
- Declared 16 nullable dataset fields from typed live cloud samples so the output contract is no longer an empty placeholder or brittle to sparse modes.

# Actor input Schema

## `mode` (type: `string`):

Scraping mode: 'search' (search by keyword), 'namespaceRepos' (all repos in a namespace/org), 'repoDetail' (single repo detail), 'tags' (repo tags list).

## `query` (type: `string`):

Optional search keyword for mode=search (e.g. 'postgres', 'nginx', 'python'). Leave empty to browse the most popular official images (no input required).

## `namespace` (type: `string`):

Docker Hub namespace for mode=namespaceRepos, repoDetail, or tags (e.g. 'library', 'bitnami', 'grafana').

## `repos` (type: `array`):

List of repository names for mode=repoDetail or mode=tags. Used together with 'namespace'. E.g. \['postgres', 'redis'].

## `maxResults` (type: `integer`):

Maximum number of results to return. Default 500. Use higher values for bulk data exports.

## `proxy` (type: `object`):

Apify proxy settings. Apify Proxy (automatic) is recommended; the Actor also works with a direct connection.

## Actor input object example

```json
{
  "mode": "search",
  "maxResults": 500,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": []
  }
}
```

# Actor output Schema

## `results` (type: `string`):

All records extracted by this run. Open the Dataset tab to browse, filter, and export as CSV, JSON, or Excel.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "proxy": {
        "useApifyProxy": true,
        "apifyProxyGroups": []
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("logiover/docker-hub-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "proxy": {
        "useApifyProxy": True,
        "apifyProxyGroups": [],
    } }

# Run the Actor and wait for it to finish
run = client.actor("logiover/docker-hub-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": []
  }
}' |
apify call logiover/docker-hub-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=logiover/docker-hub-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/FdCO7QZcZrkgaHf7z/builds/93vzlOvi8oq0T0oew/openapi.json