How to fix Error response from daemon: no matching manifest for linux/amd64 in the manifest list entries in Docker

DockerINTERMEDIATEMEDIUMUpdated Dec 6, 2025· 369 views

This error occurs when Docker cannot find an image variant built for your system's CPU architecture (linux/amd64). Common when pulling ARM-only images on Intel/AMD machines, or when using outdated tags. Fix by specifying the correct platform, finding multi-arch images, or building your own.

Quick fix

Fixes Error response from daemon: no matching manifest for linux/amd64 in the manifest list entries

# Using docker buildx imagetools (recommended)
docker buildx imagetools inspect IMAGE:TAG

# Alternative: Using manifest inspect
docker manifest inspect IMAGE:TAG

# Parse with jq to see just platforms
docker manifest inspect IMAGE:TAG | jq '.manifests[].platform'
  1. Check available platforms for the image
  2. Try a different image tag
  3. Find an alternative multi-architecture image
  4. Build your own multi-architecture image
docker — error
# Using docker buildx imagetools (recommended)
docker buildx imagetools inspect IMAGE:TAG
# Alternative: Using manifest inspect
docker manifest inspect IMAGE:TAG
# Parse with jq to see just platforms
docker manifest inspect IMAGE:TAG | jq '.manifests[].platform'
Error response from daemon: no matching manifest for linux/amd64 in the manifest list entries

What this error means

This error indicates that Docker's registry API returned a manifest list (also known as a fat manifest) that doesn't include a variant for the linux/amd64 architecture. A manifest list is an index pointing to multiple platform-specific image manifests, allowing registries to serve the correct image variant based on the client's architecture. When you pull an image, Docker sends your system's platform information (OS and architecture) to the registry. The registry looks up the manifest list for the requested image tag and tries to find a matching entry. If no entry exists for linux/amd64, this error is returned. This commonly happens when: - An image was built exclusively for ARM architecture (common with Raspberry Pi images) - The image maintainer hasn't published a linux/amd64 variant - You're using a tag that is temporarily unavailable or being rebuilt - The Docker Hub "latest" tag is being updated and momentarily missing architectures Unlike the related "platform mismatch" warning (which allows containers to run under emulation), this error completely blocks the image pull because Docker cannot find any variant to download.

Typical symptoms

  • docker pull fails with 'no matching manifest for linux/amd64 in the manifest list entries'
  • docker run fails immediately without starting the container
  • Dockerfile builds fail during FROM instruction when base image lacks amd64 support
  • CI/CD pipelines fail on x86 runners when using ARM-only images
  • Docker Compose up fails to start services using incompatible images
  • Multi-stage builds fail when a stage uses an ARM-only base image
  • Error appears after an image tag was updated or renamed on the registry

Common causes

  1. The image was built exclusively for ARM architecture (arm64, arm/v7) and doesn't include an amd64 variant
  2. Using the 'latest' tag while the image is being rebuilt on Docker Hub - architecture manifests may be temporarily unavailable
  3. The specific image tag was removed, renamed, or never included an amd64 build
  4. The image is from a registry with incomplete multi-architecture support
  5. Image maintainer deprecated x86 builds in favor of ARM-only releases
  6. Docker attestation issues in GitHub Actions causing manifest list problems during push
  7. Registry rate limiting or network issues preventing manifest retrieval
  8. Using Docker Desktop with 'Use containerd for pulling and storing images' enabled (can cause manifest resolution issues)

How to fix "Error response from daemon: no matching manifest for linux/amd64 in the manifest list entries"

1Check available platforms for the image

First, verify what platforms the image actually supports:

bash
# Using docker buildx imagetools (recommended)
docker buildx imagetools inspect IMAGE:TAG

# Alternative: Using manifest inspect
docker manifest inspect IMAGE:TAG

# Parse with jq to see just platforms
docker manifest inspect IMAGE:TAG | jq '.manifests[].platform'

Example output for a multi-arch image:

json
{
  "architecture": "amd64",
  "os": "linux"
}
{
  "architecture": "arm64",
  "os": "linux"
}

If linux/amd64 is missing from the list, you'll need to find an alternative image or build your own.

2Try a different image tag

The issue may be specific to the tag you're using. Try these alternatives:

bash
# Instead of 'latest', use a specific version
docker pull postgres:15  # instead of postgres:latest

# Check for architecture-specific tags
docker pull nginx:1.25-alpine-amd64  # if available

# Look for '-amd64' or '-x86_64' suffixed tags
docker pull some-image:v1.0-amd64

Visit the image's Docker Hub page or registry to see all available tags. Many maintainers publish architecture-specific tags alongside multi-arch manifests.

If you were using 'latest' and it just started failing, wait a few minutes - the tag may be rebuilding on Docker Hub.

3Find an alternative multi-architecture image

Search for alternative images that include amd64 support:

bash
# Search Docker Hub for similar images
docker search IMAGE_NAME

# Check official images first - they usually support multiple architectures
docker buildx imagetools inspect nginx:latest
docker buildx imagetools inspect python:3.11

Common alternatives:
- Official Docker images (docker.io/library/*)
- LinuxServer.io images (linuxserver/*)
- Bitnami images (bitnami/*)

These organizations typically maintain multi-architecture builds for their images.

4Build your own multi-architecture image

If no suitable image exists, build your own from a multi-arch base:

dockerfile
# Dockerfile
FROM --platform=linux/amd64 alpine:latest
# Or use a multi-arch base and let Docker select
FROM alpine:latest

RUN apk add --no-cache your-packages
COPY . /app
CMD ["./app"]

Build and push:

bash
# Create a builder for multi-platform builds
docker buildx create --name mybuilder --use --bootstrap

# Build for multiple architectures
docker buildx build \
  --platform linux/amd64,linux/arm64 \
  --tag your-registry/your-image:latest \
  --push \
  .

This creates a manifest list in your registry that includes both architectures.

5Disable containerd image store in Docker Desktop

A known issue with Docker Desktop 4.20+ can cause manifest resolution problems when the containerd image store is enabled:

1. Open Docker Desktop
2. Go to Settings (gear icon)
3. Select General
4. Uncheck "Use containerd for pulling and storing images"
5. Click Apply & restart

bash
# After restart, verify the setting
docker info | grep "Storage Driver"
# Should show: overlay2 (not containerd)

# Try pulling the image again
docker pull IMAGE:TAG

This reverts to the classic image store which has more mature manifest handling. Re-enable containerd after Docker releases a fix.

6Clear Docker cache and retry

Stale manifest data can sometimes cause this error. Clear the cache and retry:

bash
# Remove all unused images, containers, networks, and cache
docker system prune -a

# Clear the buildx cache specifically
docker buildx prune -a

# Pull with explicit no-cache flag
docker pull --no-cache IMAGE:TAG

# Alternative: Remove specific image and repull
docker rmi IMAGE:TAG
docker pull IMAGE:TAG

This forces Docker to fetch fresh manifest data from the registry.

7Check for GitHub Actions attestation issues

If you're building and pushing images in GitHub Actions, attestation can cause manifest list problems:

yaml
# .github/workflows/docker.yml
- name: Build and push
  uses: docker/build-push-action@v5
  with:
    platforms: linux/amd64,linux/arm64
    push: true
    tags: user/app:latest
    # Disable attestation to fix manifest issues
    provenance: false
    sbom: false

Or when using docker buildx directly:

bash
docker buildx build \
  --platform linux/amd64,linux/arm64 \
  --provenance=false \
  --sbom=false \
  --push \
  -t your-image:tag .

Attestation adds extra manifests that some registries or Docker versions don't handle correctly.

8Use QEMU emulation as a last resort

If you must use an ARM-only image on amd64, you can try emulation (with significant performance penalty):

bash
# Install QEMU handlers for cross-architecture execution
docker run --privileged --rm tonistiigi/binfmt --install all

# Try pulling with explicit ARM platform
docker pull --platform linux/arm64 IMAGE:TAG

# Run the ARM image under emulation
docker run --platform linux/arm64 IMAGE:TAG

Warning: This runs ARM binaries through QEMU emulation on your x86 host, which is:
- 2-5x slower for CPU-bound tasks
- May have compatibility issues with some binaries
- Not recommended for production use

Consider building a native amd64 version of the image instead.

Advanced notes

### Understanding Docker Manifest Lists

Docker uses manifest lists (also called "fat manifests" or "multi-arch manifests") to support multiple architectures from a single image reference. The structure looks like:

bash
image:tag
  └── manifest list (application/vnd.docker.distribution.manifest.list.v2+json)
        ├── linux/amd64 manifest → layers for x86_64
        ├── linux/arm64 manifest → layers for ARM 64-bit
        └── linux/arm/v7 manifest → layers for ARM 32-bit

When Docker pulls an image, it:
1. Fetches the manifest list from the registry
2. Filters for entries matching the client's platform
3. Downloads the matching manifest and its layers

The "no matching manifest" error occurs at step 2 when no entry matches.

### Registry-Specific Behavior

Different registries handle manifest lists differently:

| Registry | Behavior |
|----------|----------|
| Docker Hub | Full multi-arch support, may have rate limits |
| GitHub Container Registry (ghcr.io) | Full support, attestation can cause issues |
| Amazon ECR | Full support |
| Google Container Registry | Full support |
| Self-hosted registries | Varies by configuration |

### Debugging Manifest Issues

Use these commands to diagnose manifest problems:

bash
# Get raw manifest from registry (requires authentication for private images)
curl -s -H "Accept: application/vnd.docker.distribution.manifest.list.v2+json" \
  "https://registry-1.docker.io/v2/library/nginx/manifests/latest" | jq

# Check what Docker thinks your platform is
docker info --format '{{.OSType}}/{{.Architecture}}'

# Inspect local image platform
docker image inspect IMAGE:TAG --format '{{.Os}}/{{.Architecture}}'

# Enable Docker CLI debugging
DOCKER_CLI_EXPERIMENTAL=enabled docker manifest inspect IMAGE:TAG

### Common Multi-Arch Base Images

These official base images reliably support linux/amd64:

- alpine - Minimal Linux (~5MB)
- debian / ubuntu - Full Linux distributions
- python / node / golang - Language-specific bases
- nginx / postgres / redis - Popular services

Always prefer official images when possible as they maintain multi-architecture builds.

### Docker BuildKit and Manifest Lists

When building multi-platform images locally, note that:

bash
# This only keeps ONE architecture locally (last built or native)
docker buildx build --platform linux/amd64,linux/arm64 --load .

# To get a proper manifest list, you must push to a registry
docker buildx build --platform linux/amd64,linux/arm64 --push -t registry/image:tag .

# Or use the containerd image store (Docker Desktop)
docker buildx build --platform linux/amd64,linux/arm64 --load .

The --load flag with multiple platforms only works with containerd image store enabled.

Frequently asked questions

What does "Error response from daemon: no matching manifest for linux/amd64 in th" mean?
This error indicates that Docker's registry API returned a manifest list (also known as a fat manifest) that doesn't include a variant for the linux/amd64 architecture. A manifest list is an index pointing to multiple platform-specific image manifests, allowing registries to serve the correct image variant based on the client's architecture. When you pull an image, Docker sends your system's platform information (OS and architecture) to the registry.
How do I fix "Error response from daemon: no matching manifest for linux/amd64 in th"?
This error occurs when Docker cannot find an image variant built for your system's CPU architecture (linux/amd64). Common when pulling ARM-only images on Intel/AMD machines, or when using outdated tags. Fix by specifying the correct platform, finding multi-arch images, or building your own.
What causes "Error response from daemon: no matching manifest for linux/amd64 in th"?
The image was built exclusively for ARM architecture (arm64, arm/v7) and doesn't include an amd64 variant Using the 'latest' tag while the image is being rebuilt on Docker Hub - architecture manifests may be temporarily unavailable The specific image tag was removed, renamed, or never included an amd64 build
Is the "Error response from daemon: no matching manifest for linux/amd64 in th" error serious?
It is a medium-severity error — more of a blocker than a risk. The steps above resolve it.

Official resources & further reading