# Docker Hub Tag Monitor API (`automly/docker-hub-tag-monitor-api`) Actor

Monitor Docker Hub tags and latest image releases from the public Docker Hub API.

- **URL**: https://apify.com/automly/docker-hub-tag-monitor-api.md
- **Developed by:** [Automly](https://apify.com/automly) (community)
- **Categories:** Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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

## Docker Hub Tag Monitor API

**Docker Hub Tag Monitor API** collects clean, structured Docker Hub tag data for one or more repositories. Use it to monitor image releases, track latest tags, power release dashboards, and keep deployment automation up to date.

### Why use this Docker Hub tag monitor?

Docker images ship fast and break things faster. This actor gives you a simple way to watch the public Docker Hub ecosystem without building your own polling pipeline.

Typical use cases:
- Track the newest image tags for production dependencies
- Watch release cadence for third-party images
- Power notifications, dashboards, and CI/CD checks
- Feed release metadata into analytics or AI workflows

### Features

- Monitor one or more Docker Hub repositories in a single run
- Return either a compact latest-tag summary or individual tag records
- Normalize common repository formats like `nginx` and `library/redis`
- Include tag timestamps, digest, status, size, and image variant count
- Pay-per-event pricing tied to the records you actually use

### Input

#### Example: quick latest-tag check

```json
{
  "repositories": "nginx, library/redis, apify/actor-python",
  "latestTagOnly": true,
  "maxResults": 5,
  "pageSize": 50
}
````

#### Example: detailed tag monitoring

```json
{
  "repositories": "library/nginx, library/postgres",
  "latestTagOnly": false,
  "maxResults": 20,
  "pageSize": 100
}
```

#### Input fields

| Field | Type | Description |
|---|---|---|
| `repositories` | string | Comma or newline separated Docker Hub repositories to monitor, such as `nginx` or `library/redis`. |
| `latestTagOnly` | boolean | When enabled, returns one summary record per repository using the newest available tag. |
| `maxResults` | integer | Maximum number of dataset records to return across all repositories. Values above 100 are clamped. |
| `pageSize` | integer | Number of tags to request per API page. Values above 100 are clamped. |

### Output

#### Example record: latest-tag summary

```json
{
  "repositoryName": "library/nginx",
  "namespace": "library",
  "imageName": "nginx",
  "tagName": "latest",
  "tagDigest": "sha256:abc123...",
  "lastUpdated": "2026-05-26T02:00:00.000000Z",
  "lastPulled": "2026-05-26T03:00:00.000000Z",
  "lastPushed": "2026-05-26T02:00:00.000000Z",
  "tagStatus": "active",
  "imagesCount": 2,
  "fullSizeBytes": 123456789,
  "repositoryUrl": "https://hub.docker.com/r/library/nginx",
  "tagUrl": "https://hub.docker.com/r/library/nginx/tags/latest",
  "lastUpdaterUsername": "docker-bot",
  "recordType": "repository_summary"
}
```

#### Example record: tag detail

```json
{
  "repositoryName": "library/nginx",
  "namespace": "library",
  "imageName": "nginx",
  "tagName": "1.27.5",
  "tagDigest": "sha256:def456...",
  "lastUpdated": "2026-05-26T02:00:00.000000Z",
  "lastPulled": "2026-05-26T03:30:00.000000Z",
  "lastPushed": "2026-05-26T02:00:00.000000Z",
  "tagStatus": "active",
  "imagesCount": 3,
  "fullSizeBytes": 124000000,
  "repositoryUrl": "https://hub.docker.com/r/library/nginx",
  "tagUrl": "https://hub.docker.com/r/library/nginx/tags/1.27.5",
  "lastUpdaterUsername": "docker-bot",
  "recordType": "tag_record"
}
```

### Limits and caveats

- Repository names must point to public Docker Hub repositories.
- If a repository has very active tag churn, use `latestTagOnly=true` for a cheaper summary run.
- `maxResults` is capped at 100 to keep runs predictable and affordable.
- Some repositories expose more tag metadata than others.

### Pricing

This actor uses **Pay-Per-Event** pricing.

| Event | Price | Charged when |
|---|---:|---|
| `repository-summary-produced` | $0.25 / 1k | A latest-tag summary record is produced |
| `tag-record-produced` | $0.75 / 1k | An individual tag record is produced |

### FAQ

**Do I need a Docker Hub account?**\
No. The actor reads public repository metadata.

**What is the difference between summary mode and detail mode?**\
Summary mode returns one record per repository using the latest tag. Detail mode returns each tag as its own record.

**Can I monitor official images?**\
Yes. Use names like `nginx`, `redis`, or `python`; the actor will resolve them to the `library/` namespace.

**What if a repository does not exist?**\
The actor stops with a clear error message so you can fix the input quickly.

# Actor input Schema

## `repositories` (type: `string`):

Comma or newline separated Docker Hub repositories to monitor. Examples: `nginx`, `library/redis`, `apify/actor-python`. If you omit the namespace, `library/` is assumed.

## `latestTagOnly` (type: `boolean`):

When enabled, the actor returns one summary record per repository using the latest available tag. Turn it off to return individual tag records.

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

Maximum number of dataset records to return across all repositories. Values above 100 are clamped.

## `pageSize` (type: `integer`):

How many Docker Hub tags to request per API page. Values above 100 are clamped.

## Actor input object example

```json
{
  "repositories": "nginx, library/redis",
  "latestTagOnly": true,
  "maxResults": 100,
  "pageSize": 100
}
```

# Actor output Schema

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

All dataset records produced by this run.

# 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 = {
    "repositories": "nginx, library/redis",
    "latestTagOnly": true,
    "maxResults": 100,
    "pageSize": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("automly/docker-hub-tag-monitor-api").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 = {
    "repositories": "nginx, library/redis",
    "latestTagOnly": True,
    "maxResults": 100,
    "pageSize": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("automly/docker-hub-tag-monitor-api").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 '{
  "repositories": "nginx, library/redis",
  "latestTagOnly": true,
  "maxResults": 100,
  "pageSize": 100
}' |
apify call automly/docker-hub-tag-monitor-api --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Docker Hub Tag Monitor API",
        "description": "Monitor Docker Hub tags and latest image releases from the public Docker Hub API.",
        "version": "1.0",
        "x-build-id": "ehgyQBCUkuKBsFMQV"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automly~docker-hub-tag-monitor-api/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automly-docker-hub-tag-monitor-api",
                "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/automly~docker-hub-tag-monitor-api/runs": {
            "post": {
                "operationId": "runs-sync-automly-docker-hub-tag-monitor-api",
                "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/automly~docker-hub-tag-monitor-api/run-sync": {
            "post": {
                "operationId": "run-sync-automly-docker-hub-tag-monitor-api",
                "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",
                "required": [
                    "repositories"
                ],
                "properties": {
                    "repositories": {
                        "title": "Docker Hub repositories",
                        "type": "string",
                        "description": "Comma or newline separated Docker Hub repositories to monitor. Examples: `nginx`, `library/redis`, `apify/actor-python`. If you omit the namespace, `library/` is assumed."
                    },
                    "latestTagOnly": {
                        "title": "Latest tag only",
                        "type": "boolean",
                        "description": "When enabled, the actor returns one summary record per repository using the latest available tag. Turn it off to return individual tag records."
                    },
                    "maxResults": {
                        "title": "Maximum records",
                        "type": "integer",
                        "description": "Maximum number of dataset records to return across all repositories. Values above 100 are clamped."
                    },
                    "pageSize": {
                        "title": "Tags per page",
                        "type": "integer",
                        "description": "How many Docker Hub tags to request per API page. Values above 100 are clamped."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```