Docker Hub API

A Docker Hub API with the registry's two lookups in one collector: a Docker Hub search query returns matching images as rows — name, description, stars, pull count, official and automated flags — while a list of exact references ("redis", "bitnami/postgresql") returns each repository's full record with its last-updated date. The image stats arrive as flat columns from Docker's keyless v2 endpoints, not a page to scrape.

Get my free API key See the request

$0.0003 per delivered image · $2 free every month · Failed runs never billed

POST /v1/scraper/collectors/docker_hub/run

$ curl $QD/docker_hub/run \
    -H "Authorization: Bearer $QD_API_KEY" \
    -d '{}'
{ "status": "done", "count": 10,
  "results": [
    {
      "name": "…",
      "description": "…",
      "stars": …,
      "pulls": … } ],
  "cost": 0.003 }
# 10 images × $0.0003 · nothing delivered, nothing charged

$0.0003 / image6,666 images on the free $2 every month

Semantic inputquery, images, max_results — no URL lists

Up to 100images per run, pagination handled for you

No browserread over HTTP/TLS — cheaper and faster than rendering

What a Docker Hub API does

Docker's registry API is free at origin; what it does not give you is a table. Search results and repository records come from different endpoints with different JSON shapes, and this collapses both into one row schema — so a Docker registry API pull lands next to your npm and crates rows in the same envelope, under the same single key.

Detail mode takes up to 50 exact references per call — redis, library/redis, bitnami/postgresql all resolve — and adds the last_updated date that search results do not carry. References that resolve to nothing are reported under failed and left off the bill, so a stale image list does not silently thin your dataset.

What one image looks like

Every delivered image carries these fields. Nullable means the source did not publish it — the field stays empty instead of being guessed.

Field	Type	What it holds
`rank`	integer	1-based position.
`name`	string	Image name (namespace/name; officials bare).
`description`	string · nullable	Short description.
`stars`	integer · nullable	Stars.
`pulls`	integer · nullable	Total pulls.
`is_official`	boolean	Docker official image.
`is_automated`	boolean	Automated build.
`last_updated`	string · nullable	Last push (detail mode only).
`url`	string	Docker Hub page.

Inputs

The whole request. Anything you leave out falls back to the default shown in the catalog.

Input	Type	Required	What it does
`query`	string	no	Image search query (leave empty when passing images).
`images`	array	no	Exact references for detail lookups — "redis" or "namespace/name".
`max_results`	integer	no	How many images to deliver at most (1–100). You pay only for delivered images.

Pricing

Docker Hub API pricing

$0.0003 per delivered image. A run that delivers nothing costs nothing: blocked pages, challenges and retries are on us, and the $2 monthly allowance covers about 6,666 images before you spend anything.

$0.0003per delivered image$0.3 per 1,000 delivered images

6,666 imageson the free allowance$2 every month, no card

Zero rowszero chargeblocks, captchas and retries are on us

−30%on volume tiersthe catalog returns your key's price

Pay as you go

$0/mo

$2 free credit / month
60 requests / min
List unit prices

Starter

$19/mo

$15 free credit / month
300 requests / min
10% off unit prices

Growth

$79/mo

$50 free credit / month
600 requests / min
20% off unit prices

Scale

$299/mo

$250 free credit / month
1,200 requests / min
30% off unit prices

Same wallet, same key and same $2 monthly allowance as every other Data API. Prices are launch pricing read live from the billing config — GET /v1/scraper/collectors returns the price your key actually pays.

Integration

One POST, typed rows

Base URL https://api.quanticdata.io/v1, Bearer auth, the same key as every other Data API. Endpoint: POST /v1/scraper/collectors/docker_hub/run.

curl -X POST https://api.quanticdata.io/v1/scraper/collectors/docker_hub/run \
  -H "Authorization: Bearer $QD_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{}'

import requests

r = requests.post(
    "https://api.quanticdata.io/v1/scraper/collectors/docker_hub/run",
    headers={"Authorization": f"Bearer {QD_API_KEY}"},
    json={},
    timeout=120,
)
for row in r.json()["payload"]["results"]:
    print(row)

const res = await fetch(
  "https://api.quanticdata.io/v1/scraper/collectors/docker_hub/run",
  {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.QD_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({}),
  },
);
const { payload } = await res.json();
console.table(payload.results);

claude mcp add quantumproxies \
  -e QUANTUMPROXIES_API_KEY=qd_live_your_key_here \
  -- npx -y quantumproxies-mcp

# then, in the chat:
> run the docker_hub collector with

What people build with the Docker Hub API

Three shapes of work this endpoint was designed around.

Base image vetting

Rank candidate images by pull count, stars and the is_official flag before one goes into a Dockerfile, from a query instead of a browsing session.

Registry watchlists

Re-run detail lookups on the images you deploy and diff last_updated against the previous pull to see which upstream images have moved.

Ecosystem adoption tables

Search a technology keyword and store the ranked rows — pulls and stars sampled over time turn into an adoption curve for whatever you track.

Docker Hub API versus rolling your own

The differences that actually cost time when you build this in-house.

	DIY scraper	This collector
Two modes	Separate search and repository endpoints to stitch	One collector: a query to search, references for detail
Image stats	Counts buried in paged registry JSON	Pull count, stars and flags as columns on every row
Dead references	A 404 you handle mid-loop	Reported under failed, off the bill

FAQ

Questions we get about the Docker Hub API.

Something else? Ask us →

Does the Docker Hub API require authentication?

Not for this. Docker Hub's v2 search and repository endpoints answer without credentials, so nothing extra is registered or stored — usage is metered on the QuanticData key you already hold, like every collector in the catalog.

How do I get the pull count for a specific image?

Pass it under images — "redis" for an official image, "namespace/name" otherwise — and the returned row carries pulls, stars, both flags and last_updated, which only detail mode includes.

Does it return tags or image manifests?

No. Rows describe the repository — stats, flags, freshness — not its tag list or manifests. It is the adoption and popularity layer for datasets, not a registry client for pulling images.

Is there a free Docker Hub API?

Every account gets $2 of credit every month with no card, which is about 6,666 delivered images on this endpoint at $0.0003 each. It renews monthly, and a run that delivers nothing is never billed — so a failed or blocked attempt does not eat the allowance.

How much does one run cost?

Multiply the rows you actually receive by $0.0003. A run capped at 100 images — the maximum for this collector — costs $0.03 if every row comes back, and less when the source has fewer. Volume tiers take up to 30% off, and GET /v1/scraper/collectors returns the price your key actually pays.

Run the Docker Hub API now

$2 of free credit every month, no card. Your key returns its own prices from GET /v1/scraper/collectors.

Get my free API key