Free Docker Image Hosting: Docker Hub, GHCR, and the Limits That Are Actually Real

Free Docker image hosting comes from four registries worth comparing: Docker Hub’s Personal plan (unlimited public repositories, one private repository, and a pull-rate limit that applies to anonymous and free-tier pulls), GitHub Container Registry or GHCR (free storage and, per GitHub’s own docs, a 10GB per-layer limit rather than a documented pull-rate cap), GitLab’s container registry (free on GitLab.com with project-tied storage), and Quay (Red Hat’s registry, with its own free tier for public images). All four store image layers. None of them run the container for you, hosting an image and running it are two different services, and conflating them is the mistake that shows up when someone expects a free registry to also provide compute.

Docker Hub and GHCR dominate this topic’s search results, and the numbers reported for both vary across sources, one telling puts Docker Hub’s free-tier pull limit around 100 pulls per hour, another reports 200 pulls per six hours, and GHCR’s public-image pull behavior is described by community reports as unlimited while GitHub’s own documentation focuses on a 10GB per-layer storage limit instead of a pull cap. This post compares all four free registries honestly, flags where the numbers are reported rather than officially pinned down, and draws the line between hosting an image and running it, which is where a free registry’s job actually ends.

Table of contents

• The four free registries, compared
• Docker Hub’s free Personal plan: what’s actually free
• GitHub Container Registry (GHCR): what GitHub’s own docs say
• GitLab Container Registry and Quay: the two everyone forgets
• Hosting an image is not running it
• Pushing and pulling: the commands, once you’ve picked one
• How this fits the rest of the stack
• FAQ

The four free registries, compared

All four store image layers and serve them back on a pull. None of them run anything for you, which is worth stating up front before comparing the details that differ between them.

• Docker Hub: unlimited public repositories on the free Personal plan, one private repository, and a pull-rate limit that applies to anonymous and free-tier authenticated pulls, worth checking on Docker’s own pricing page since the exact number has moved over time.
• GitHub Container Registry (GHCR): free storage for public images with, per GitHub’s own documentation, a 10GB limit per layer and a 10-minute upload timeout rather than a published pull-rate cap; private image storage has historically counted against a GitHub Packages storage allowance.
• GitLab Container Registry: free on GitLab.com, tied to a project’s storage rather than a separate registry-specific plan, useful if the code already lives on GitLab and the registry should sit next to it.
• Quay (Red Hat): a free tier for public images, positioned similarly to Docker Hub and GHCR for open-source projects wanting a registry outside their main code host.

Numbers on pull limits specifically are the least stable part of this comparison, providers have changed them before and will again, so treat any specific figure, including the ones in this post, as a snapshot worth re-checking on the provider’s own page before it matters for a production pipeline.

Docker Hub’s free Personal plan: what’s actually free

Our own breakdown of Docker’s pricing across Personal, Pro, Team, and Business covers where Docker Hub’s free Personal plan sits against the paid tiers; the part worth restating here is what free actually includes: unlimited public repositories, one private repository, and a pull limit stated as roughly 100 image pulls per hour in one telling, while other sources report Docker Hub’s anonymous and free-tier limit closer to 200 pulls per six hours. The two figures are not necessarily contradictory, hourly and six-hourly windows describe the same policy differently, but the discrepancy itself is the useful takeaway: the exact number is not stable enough to hardcode into a CI pipeline’s assumptions without checking Docker’s current pricing page directly.

What does not seem to vary between sources is the shape of the limit: it applies per anonymous IP address or per free account, authenticating raises it, and a paid plan raises it further. A CI pipeline pulling the same public base image on every build is the workload most likely to hit this limit in practice, not a one-off manual pull.

GitHub Container Registry (GHCR): what GitHub’s own docs say

GitHub’s documentation is specific and primary-source reliable here: the Container Registry has a 10GB size limit for each layer and a 10-minute timeout limit for uploads. It does not publish a documented pull-rate limit for public images the way Docker Hub does, and a Reddit thread comparing the two describes GHCR as having no rate limit on public or private image pulls, though that describes community-reported behavior rather than a formal guarantee in GitHub’s own docs.

echo $CR_PAT | docker login ghcr.io -u USERNAME --password-stdin
docker push ghcr.io/namespace/image:latest

For a project already hosted on GitHub, GHCR has an obvious convenience advantage, authentication reuses the same token a workflow already has in CI, with no separate account or credential to manage. Private image storage is the part to check current pricing on directly, since free-tier storage allowances for private GitHub Packages have been reported differently across sources and are worth confirming rather than assuming.

GitLab Container Registry and Quay: the two everyone forgets

GitLab’s Container Registry ships free on GitLab.com, scoped to a project rather than sold as a separate product, which makes it the natural choice for anything already using GitLab for source control and CI, the registry is just another tab on the same project rather than a second account to create. Quay, run by Red Hat, offers a free tier aimed at public and open-source images, positioned similarly to Docker Hub for projects that want a registry independent of their main code host.

Neither showed up in the search results that dominate this topic, which are mostly Docker Hub versus GHCR comparisons, but both are real, current options worth knowing about specifically because they are not the default answer everyone reaches for first. This post is deliberately conservative about specific numbers for both, storage limits and rate limits for GitLab and Quay change and are best confirmed on each provider’s current pricing page rather than repeated from a post that will age.

Hosting an image is not running it

A registry answers one question: where does the built image live between docker push and whatever pulls it next. It does not answer where that image actually runs, what happens when the process it starts crashes, how environment variables and secrets reach the running container, or how a request from outside finds its way to it. Those are the job of somewhere with compute, not somewhere with storage, and conflating the two is the single most common expectation mismatch people run into with a free registry: it hosts the image perfectly and does nothing else.

We have covered a production path for deploying a Docker image that does not break at 3am and the checklist that keeps a registry from becoming the incident, and both assume the registry question from this post is already settled, because it usually is the easy half.

Pushing and pulling: the commands, once you’ve picked one

The commands are nearly identical across all four registries, only the hostname and the login step change.

# Docker Hub
docker login
docker tag myapp:latest username/myapp:latest
docker push username/myapp:latest

# GHCR
docker login ghcr.io -u USERNAME
docker tag myapp:latest ghcr.io/username/myapp:latest
docker push ghcr.io/username/myapp:latest

Pulling is the same shape in reverse, docker pull //:, and it is the pull side, not the push side, where free-tier rate limits actually bite, since a CI pipeline or a fleet of running services typically pulls the same image far more often than anyone pushes a new version of it. Tagging consistently, avoiding a bare latest in anything that matters for reproducibility, matters more once the image is being pulled from somewhere with a rate limit attached to it, so a stale cache does not quietly serve the wrong version under pressure.

How this fits the rest of the stack

A free registry solves exactly one part of running a container: somewhere for the image to live between being built and being pulled. Getting it running still needs compute, a restart policy for when the process dies, environment variables, and a route the outside world can reach, none of which a registry provides. RunxBuild runs Docker services directly from a pushed image or a repository, with a build log, a live route, and rollback to the previous image if a new one goes bad. The RunxBuild hosting calculator prices the compute side once the image itself already has somewhere free to live.

Useful related references:

• Container Registry Security: The Short Checklist That Prevents the Long Incident
• How to Deploy a Docker Image: A Production Path That Does Not Break at 3am
• Docker Pricing: Personal, Pro, Team, Business (and the Free Tier)
• Docker services on RunxBuild

FAQ

Is Docker Hub actually free?

For public images, yes: the Personal plan includes unlimited public repositories at no cost. It also includes exactly one private repository free, and a pull-rate limit applies to anonymous and free-tier pulls, reported differently across sources, roughly 100 pulls per hour in one account, 200 per six hours in another, so check Docker’s current pricing page for the exact figure before relying on it in production.

Does GitHub Container Registry (GHCR) have pull limits?

GitHub’s own documentation specifies a 10GB per-layer size limit and a 10-minute upload timeout, but does not publish a pull-rate limit for public images the way Docker Hub does. Community reports describe effectively no rate limit on public image pulls, though that is observed behavior rather than a documented guarantee, worth confirming for anything rate-sensitive.

What is the difference between hosting a Docker image and running it?

Hosting means a registry stores the built image’s layers and serves them on a pull, nothing more. Running means something with compute actually starts the container, keeps the process alive, restarts it if it crashes, and routes external traffic to it. A free registry solves only the first half; the second half needs an actual host.

Can I use a free registry for a private company image?

Docker Hub’s free plan includes one private repository, and GitHub Container Registry ties private image storage to a GitHub Packages storage allowance that has varied across reporting periods. For more than a single private image, or for a team, checking the current paid-tier pricing on whichever registry you use is worth doing before assuming the free tier covers it.

Which free Docker registry should I use?

Whichever one sits next to where the code already lives: GHCR if the repository is on GitHub, GitLab’s Container Registry if the code is on GitLab, Docker Hub if neither applies or public discoverability matters, and Quay as a code-host-independent option. All four store images equally well; the deciding factor is usually workflow convenience, not a feature gap.