# Docker Hub Scraper | Container Image Metadata (`parseforge/dockerhub-scraper`) Actor

Scrape Docker Hub repositories for image names, descriptions, pull counts, star ratings, tags, last updated dates and publisher details. Track container popularity, monitor official images and build datasets of the Docker ecosystem for DevOps research and tooling

- **URL**: https://apify.com/parseforge/dockerhub-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Developer tools, Developer examples, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $19.00 / 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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🐳 Docker Hub Scraper

> 🚀 **Export Docker Hub repositories and images in seconds.** Search by keyword or list every repo in a namespace. Get pull counts, star counts, descriptions, and categories. No API key needed.

> 🕒 **Last updated:** 2026-05-22 · **📊 13 fields** per record · **🐳 1,000,000+ public images** · **🌐 Two scraping modes** · **⚡ Real-time data**

The **Docker Hub Scraper** pulls live repository data from Docker Hub's public REST API and returns structured records for every image matched by your search or namespace. Each record includes the repository name, namespace, description, pull count, star count, official status, privacy flag, last-updated timestamp, categories, and a direct URL to the image page.

Docker Hub is the world's largest container image registry, hosting over 100,000 public repositories from official maintainers, software vendors, and the open-source community. This Actor makes that data downloadable as CSV, Excel, JSON, or XML in under a minute - no Docker account, no API key, no scraping boilerplate.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| DevOps engineers, platform teams, security researchers, data analysts, OSS maintainers, container consultants | Dependency audits, image popularity tracking, namespace monitoring, competitive research, container supply-chain analysis |

---

### 📋 What the Docker Hub Scraper does

Two data-collection modes in a single run:

- 🔍 **Search mode.** Full-text search across all public Docker Hub repositories. Find images by name, technology, or purpose - returns pull counts and star counts sorted by relevance.
- 📦 **Namespace mode.** List every public repository owned by a user or organization (e.g. `bitnami`, `library`, `nginx`). Returns richer data including last-updated timestamps and category tags.
- 📊 **Pagination.** Automatically walks all result pages until your `maxItems` limit is reached.
- ⚡ **Real-time.** Every run fetches live data directly from the Docker Hub v2 API - no cached snapshots.
- 🔓 **No auth required.** The public API is used throughout - no Docker Hub account or API key needed.

> 💡 **Why it matters:** Docker Hub has no bulk-export feature. Auditing image popularity, tracking namespace growth, or feeding a container-intelligence dashboard requires either writing your own paginator or scraping by hand. This Actor handles all of that and returns clean, structured JSON on every run.

---

### 🎬 Full Demo

_🚧 Coming soon: a 3-minute walkthrough showing how to go from sign-up to a downloaded dataset._

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td>maxItems</td><td>integer</td><td>10</td><td>Records to return. Free plan caps at 10, paid plan at 1,000,000.</td></tr>
<tr><td>searchQuery</td><td>string</td><td>"nginx"</td><td>Full-text search query. Used when Namespace is not set. Defaults to "nginx" if both fields are empty.</td></tr>
<tr><td>namespace</td><td>string</td><td>-</td><td>Docker Hub username or org (e.g. library, bitnami, nginx). Takes priority over Search Query when provided.</td></tr>
</tbody>
</table>

**Example 1 - Search for Python images:**
```json
{
  "searchQuery": "python",
  "maxItems": 50
}
````

**Example 2 - List all Bitnami repositories:**

```json
{
  "namespace": "bitnami",
  "maxItems": 100
}
```

> ⚠️ **Good to Know:** If neither `searchQuery` nor `namespace` is provided, the Actor defaults to searching `"nginx"`. Search mode and namespace mode return slightly different fields - `lastUpdated` and `categories` are only populated in namespace mode, since the Docker Hub search API does not return those fields.

***

### 📊 Output

Each record contains the following fields:

| Field | Type | Description |
|---|---|---|
| 📛 `name` | string | Repository name (without namespace prefix) |
| 🏢 `namespace` | string | Owner username or organization |
| 🔗 `fullName` | string | Combined `namespace/name` identifier |
| 📝 `description` | string | Short repository description |
| 📥 `pullCount` | number | Total number of image pulls |
| ⭐ `starCount` | number | Number of stars |
| ✅ `isOfficial` | boolean | True if this is an official Docker image |
| 🔒 `isPrivate` | boolean | True if the repository is private |
| 🕒 `lastUpdated` | string | ISO 8601 timestamp of last push (namespace mode only) |
| 🏷️ `categories` | array | Category tags (namespace mode only, e.g. "Databases & storage") |
| 🌐 `url` | string | Direct URL to the Docker Hub image page |
| 📅 `scrapedAt` | string | ISO 8601 timestamp of when the record was collected |
| ❌ `error` | string | Error message if the record could not be fetched |

**Sample records - search mode** (`searchQuery: "nginx"`, 3 of 5 shown):

```json
[
  {
    "name": "nginx",
    "namespace": "library",
    "fullName": "nginx",
    "description": "Official build of Nginx.",
    "pullCount": 13022750244,
    "starCount": 21279,
    "isOfficial": true,
    "isPrivate": false,
    "lastUpdated": null,
    "categories": null,
    "url": "https://hub.docker.com/_/nginx",
    "scrapedAt": "2026-05-22T00:15:18.335Z",
    "error": null
  },
  {
    "name": "nginx-ingress",
    "namespace": "nginx",
    "fullName": "nginx/nginx-ingress",
    "description": "NGINX and  NGINX Plus Ingress Controllers for Kubernetes",
    "pullCount": 1085333058,
    "starCount": 120,
    "isOfficial": false,
    "isPrivate": false,
    "lastUpdated": null,
    "categories": null,
    "url": "https://hub.docker.com/r/nginx/nginx-ingress",
    "scrapedAt": "2026-05-22T00:15:18.335Z",
    "error": null
  },
  {
    "name": "nginx-prometheus-exporter",
    "namespace": "nginx",
    "fullName": "nginx/nginx-prometheus-exporter",
    "description": "NGINX Prometheus Exporter for NGINX and NGINX Plus",
    "pullCount": 87347846,
    "starCount": 51,
    "isOfficial": false,
    "isPrivate": false,
    "lastUpdated": null,
    "categories": null,
    "url": "https://hub.docker.com/r/nginx/nginx-prometheus-exporter",
    "scrapedAt": "2026-05-22T00:15:18.335Z",
    "error": null
  }
]
```

**Sample records - namespace mode** (`namespace: "bitnami"`, 2 of 5 shown):

```json
[
  {
    "name": "redis",
    "namespace": "bitnami",
    "fullName": "bitnami/redis",
    "description": "Bitnami Secure Image for redis",
    "pullCount": 3339283423,
    "starCount": 365,
    "isOfficial": false,
    "isPrivate": false,
    "lastUpdated": "2026-05-11T17:18:16.783773Z",
    "categories": ["Databases & storage", "Message queues", "Monitoring & observability"],
    "url": "https://hub.docker.com/r/bitnami/redis",
    "scrapedAt": "2026-05-22T00:09:00.964Z",
    "error": null
  },
  {
    "name": "nginx",
    "namespace": "bitnami",
    "fullName": "bitnami/nginx",
    "description": "Bitnami Secure Image for nginx",
    "pullCount": 435962728,
    "starCount": 205,
    "isOfficial": false,
    "isPrivate": false,
    "lastUpdated": "2026-05-20T12:43:53.736954Z",
    "categories": ["API management", "Security", "Web servers"],
    "url": "https://hub.docker.com/r/bitnami/nginx",
    "scrapedAt": "2026-05-22T00:09:00.964Z",
    "error": null
  }
]
```

***

### ✨ Why choose this Actor

| Feature | Details |
|---|---|
| 🔓 No auth required | Public Docker Hub API - no Docker account or token needed |
| ⚡ Fast | A page of 25 results returns in under 1 second |
| 📦 Two modes | Search by keyword or enumerate a full namespace |
| 🏷️ Categories | Namespace mode returns category tags not visible in search |
| 📥 Pull counts | Exact pull counts for every image, updated live |
| 📄 Multi-format export | CSV, Excel, JSON, XML - all from Apify's dataset UI |
| 🔁 Pagination | Walks all pages automatically up to your `maxItems` cap |
| 💰 Pay-per-result | Only charged for real data records, never for errors |

***

### 📈 How it compares to alternatives

| Method | Effort | Pagination | Export formats | Real-time |
|---|---|---|---|---|
| **This Actor** | Zero code | Automatic | CSV, Excel, JSON, XML | Yes |
| Docker Hub UI | Manual copy | No bulk export | None | Yes |
| Docker Hub CLI | Requires Docker + auth | Manual | Terminal output only | Yes |
| Custom script | Hours of development | Manual coding | Custom | Yes |

***

### 🚀 How to use

1. [Create a free account](https://console.apify.com/sign-up?fpr=vmoqkp) on Apify (includes $5 credit).
2. Open the **Docker Hub Scraper** actor page.
3. Set `searchQuery` (e.g. `"postgres"`) or `namespace` (e.g. `"bitnami"`).
4. Set `maxItems` to the number of records you need.
5. Click **Start** and wait for the run to finish (typically under 30 seconds for 100 items).
6. Download results as CSV, Excel, JSON, or XML from the **Dataset** tab.

***

### 💼 Business use cases

#### Container security and compliance

Security teams use pull-count and official-status data to build an approved image registry. Filter by `isOfficial: true` to enforce policies that only allow vetted base images. Compare pull counts across candidate images to gauge community adoption before approving a new dependency.

#### Competitive intelligence for container vendors

ISVs distributing software via Docker Hub track their own namespace pull growth and compare it against competing namespaces. Running the scraper weekly against a list of competitor namespaces produces a time-series that reveals release cadence, adoption velocity, and community momentum.

#### Open-source ecosystem research

Researchers studying container adoption patterns use this Actor to build datasets of image popularity over time. Filtering by category tags (namespace mode) enables segmented analysis - e.g. comparing pull growth in "Databases & storage" vs. "Security" images across a given quarter.

#### DevOps dependency auditing

Platform teams maintaining internal Kubernetes clusters need to know the last-updated timestamps for every third-party image in their stack. The namespace mode returns `lastUpdated` for all repos in an org, making it trivial to flag images not updated in 90+ days and escalate them for replacement.

***

### 🔌 Automating Docker Hub Scraper

Connect this Actor to automation platforms for hands-free container intelligence:

- **Make (Integromat)** - Schedule weekly namespace scans and push results to a Google Sheet or Airtable database.
- **Zapier** - Trigger a Zap when a run completes and send a summary to Slack or email.
- **Slack** - Post pull-count milestones or image-staleness alerts directly to your DevOps channel.
- **Google Sheets** - Use the Apify Google Sheets integration to append each run's results to a tracking spreadsheet.
- **Webhooks** - Fire a webhook on run completion to trigger downstream CI/CD pipelines or data warehouse ingestion.

***

### 🌟 Beyond business use cases

#### Academic research

Container ecosystem studies, software-supply-chain papers, and open-source adoption research all benefit from structured Docker Hub data. Export the full dataset for a namespace or technology category and analyze it in R, Python, or Excel.

#### OSS project maintenance

Open-source maintainers track their image's pull count over time to measure project adoption, correlate releases with pull spikes, and include accurate download statistics in project READMEs and grant applications.

#### Creative and community projects

DevRel teams, conference speakers, and Docker community evangelists use pull-count leaderboards to tell the story of container adoption. Build visual dashboards, blog posts, or infographics showing which images are powering the world's infrastructure.

#### Experimentation and prototyping

Students and hobbyists exploring container technologies can quickly enumerate what's available in the `library` namespace to discover official images across every major technology stack - databases, runtimes, web servers, message queues, and more.

***

### 🤖 Ask an AI assistant about this scraper

Not sure which mode to use or how to process the output? Paste this prompt into any AI assistant:

> "I'm using the Docker Hub Scraper on Apify (parseforge/dockerhub-scraper). It has two modes: search mode using a `searchQuery` string, and namespace mode using a `namespace` like 'bitnami'. Help me \[describe your goal]."

***

### ❓ Frequently Asked Questions

#### 🔑 Do I need a Docker Hub account or API key?

No. The Actor uses the public Docker Hub v2 REST API which requires no authentication for public repository data.

#### 🔍 What does search mode search?

Search mode queries the Docker Hub full-text search index. It matches against image names, descriptions, and namespace names. Results are sorted by relevance, with official images typically ranking first.

#### 📦 What is namespace mode?

Namespace mode lists every public repository owned by a specific Docker Hub user or organization. For example, `namespace: "bitnami"` returns all 276+ repositories in the Bitnami organization.

#### 🕒 Why is `lastUpdated` null in search mode?

The Docker Hub search API (`/v2/search/repositories/`) does not return `last_updated` timestamps. Use namespace mode (`/v2/repositories/{namespace}/`) if you need timestamps.

#### 🏷️ Why are `categories` null in search mode?

Category tags are only available in the namespace API response. They are not returned by the search endpoint.

#### 🔢 How many items can I scrape?

Free plan users are limited to 10 items per run. Paid plan users can scrape up to 1,000,000 items per run. Docker Hub search returns up to 285,000+ results for broad queries; namespace endpoints return all public repos for an organization.

#### ⚡ How fast is it?

The Actor fetches 25 results per API request. A run collecting 100 items completes in under 5 seconds on Apify's infrastructure.

#### 💰 How am I charged?

The Actor uses pay-per-result pricing. You are only charged for records that are successfully scraped and pushed to the dataset. Error records are never charged.

#### 🔄 Can I run this on a schedule?

Yes. Use Apify's built-in scheduler to run the Actor daily, weekly, or on any cron schedule. Results accumulate in your dataset over time.

#### 🛡️ Is this against Docker Hub's terms of service?

This Actor only accesses Docker Hub's publicly documented REST API, which is designed for programmatic access to public repository data. No authentication is bypassed, no private data is accessed, and all requests respect the API's documented structure.

#### 📊 Can I export to Excel?

Yes. Every Apify dataset can be downloaded as CSV, Excel (XLSX), JSON, XML, or RSS from the dataset UI or via the Apify API.

#### 🔗 Can I get the full image details page data?

The current Actor collects all fields available from the search and repository listing endpoints. Detailed image metadata (tags, architecture manifests, vulnerability scan results) is available from separate Docker Hub endpoints and may be added in a future version.

***

### 🔌 Integrate with any app

Apify datasets connect natively with hundreds of platforms:

| Integration | How |
|---|---|
| **Google Sheets** | Apify Google Sheets Actor or Zapier |
| **Airtable** | Zapier or Make webhook |
| **Slack** | Apify notifications or Make scenario |
| **Make (Integromat)** | HTTP module watching the dataset |
| **Zapier** | Apify trigger on run completion |
| **Power BI** | JSON dataset endpoint as a data source |
| **Tableau** | CSV download or JSON connector |
| **Python / pandas** | Apify client (`apify-client`) or direct API |
| **Node.js** | `apify-client` npm package |
| **REST API** | `GET /v2/datasets/{datasetId}/items` |

***

### 🔗 Recommended Actors

| Actor | What it does |
|---|---|
| [PyPI Scraper](https://apify.com/parseforge/pypi-scraper) | Search Python packages on PyPI and extract download stats, metadata, and classifiers |
| [npm Registry Scraper](https://apify.com/parseforge/npm-registry-scraper) | Search npm packages and extract weekly downloads, license, repository, and maintainer data |
| [GitHub Scraper](https://apify.com/parseforge/dev-to-scraper) | Scrape dev.to articles, tags, and author profiles for developer content research |

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) to find scrapers for 80+ public data sources - all maintained, all pay-per-result.

***

*This Actor accesses only publicly available Docker Hub data via the official REST API. It is not affiliated with, endorsed by, or connected to Docker, Inc. Docker and Docker Hub are trademarks of Docker, Inc. Use responsibly and in accordance with Docker Hub's terms of service.*

# Actor input Schema

## `maxItems` (type: `integer`):

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## `searchQuery` (type: `string`):

Search Docker Hub for images (e.g. 'nginx', 'python', 'postgres'). Used when Namespace is not set.

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

List all repos for a Docker Hub user or organization (e.g. 'library', 'nginx', 'bitnami'). Takes priority over Search Query.

## Actor input object example

```json
{
  "maxItems": 10,
  "searchQuery": "nginx"
}
```

# Actor output Schema

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

No description

# 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 = {
    "maxItems": 10,
    "searchQuery": "nginx"
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/dockerhub-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 = {
    "maxItems": 10,
    "searchQuery": "nginx",
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/dockerhub-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 '{
  "maxItems": 10,
  "searchQuery": "nginx"
}' |
apify call parseforge/dockerhub-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Docker Hub Scraper | Container Image Metadata",
        "description": "Scrape Docker Hub repositories for image names, descriptions, pull counts, star ratings, tags, last updated dates and publisher details. Track container popularity, monitor official images and build datasets of the Docker ecosystem for DevOps research and tooling",
        "version": "0.1",
        "x-build-id": "l2hyZXKbIE02I4OP8"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~dockerhub-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-dockerhub-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/parseforge~dockerhub-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-dockerhub-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/parseforge~dockerhub-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-dockerhub-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Search Docker Hub for images (e.g. 'nginx', 'python', 'postgres'). Used when Namespace is not set."
                    },
                    "namespace": {
                        "title": "Namespace / Organization",
                        "type": "string",
                        "description": "List all repos for a Docker Hub user or organization (e.g. 'library', 'nginx', 'bitnami'). Takes priority over Search Query."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
