OpenClaw Docker Image: Size, Tags, and Optimization Guide

Image Size Breakdown

The OpenClaw Docker image is a Node.js application with a substantial dependency tree. Here is what makes up the image size:

Total uncompressed: approximately 1.8-2.2GB on disk. Compressed (as pulled from Docker Hub): approximately 850MB-1.1GB. The compressed size is what matters for download time and bandwidth.

The biggest contributor is Puppeteer with its bundled Chromium browser, which accounts for about 25% of the total image size. If you do not need browser automation capabilities (web scraping, screenshot generation, HTML-to-PDF conversion), the slim tag removes Puppeteer entirely and saves about 500MB.

The node_modules directory is the second biggest component. OpenClaw has a large dependency tree because it includes adapters for all 50+ supported integrations, even if you only use one or two. Each integration has its own dependencies, and they all ship in the default image.

Available Tags and When to Use Each

OpenClaw publishes multiple Docker image tags. Choosing the right one matters for both size and stability:

latest — The most recent stable release. This is what you get with docker pull openclaw/openclaw. Includes all integrations, Puppeteer, and the full feature set. Use this for production deployments where you want the complete platform.

3.23 (version-specific) — A specific major.minor release. Pinning to a version tag prevents surprise updates. Use this in production when you want to control exactly which version you are running. Update by changing the tag in your docker-compose.yml rather than relying on latest.

3.23.1 (patch-specific) — A specific patch release. The most deterministic option. Use this for maximum reproducibility. If you deploy the same tag on different servers, you are guaranteed identical behavior.

slim — A smaller image (~600MB compressed) that excludes Puppeteer/Chromium, optional native bindings, and rarely-used integrations. Use this if you do not need browser automation and want to save disk space and pull time. All core features (model routing, messaging channels, skills, memory) are included.

dev — Development builds from the main branch. These may contain unreleased features and bugs. Do not use in production. Only use for testing upcoming features or contributing to OpenClaw development.

For most operators, the recommendation is: use a version-specific tag like 3.23 in production. This gives you stability (no unexpected updates) with the flexibility to receive patch releases within that version. Update to new versions deliberately by changing the tag.

Multi-Architecture Support

OpenClaw publishes multi-architecture images supporting both AMD64 (standard x86-64 servers) and ARM64 (Apple Silicon, Raspberry Pi 5, ARM-based VPS like Oracle Ampere). Docker automatically pulls the correct architecture for your platform.

You do not need to specify the architecture when pulling. docker pull openclaw/openclaw:3.23 automatically downloads the AMD64 version on x86 servers and the ARM64 version on ARM servers.

ARM64 images are slightly larger than AMD64 images (typically 5-10% bigger) because some native bindings require additional compilation artifacts on ARM. This is a minor difference and does not affect functionality.

If you are building custom images on Apple Silicon (M1/M2/M3/M4), be aware that the default build produces an ARM64 image. If you need to deploy to an AMD64 server, build with:

docker build --platform linux/amd64 -t my-openclaw .

The Slim Tag: What Is Removed

The slim tag is approximately 40% smaller than the standard image. Here is exactly what is removed:

• Puppeteer and Chromium: Browser automation is not included. Skills that use web scraping, screenshot generation, or HTML rendering will not work. This saves approximately 500MB.
• Sharp (image processing): Advanced image processing (resize, convert, compress) is not included. Basic image handling still works through the built-in Node.js canvas library. Saves approximately 80MB.
• FFmpeg bindings: Audio and video processing is not included. If your agent needs to handle voice messages or media files, use the full image. Saves approximately 50MB.
• Rarely-used integration adapters: Some integrations that require heavy native dependencies (like the Oracle DB adapter, SAP connector, and LDAP client) are excluded. The core messaging integrations (WhatsApp, Telegram, Discord, Slack, email) are all included. Saves approximately 70MB.

For most operators who use OpenClaw as a messaging bot and task automation agent, the slim tag includes everything needed. The removed components are specialized features that the majority of deployments do not use.

To switch to the slim tag, update your docker-compose.yml:

image: openclaw/openclaw:slim

Or for a version-specific slim build:

image: openclaw/openclaw:3.23-slim

Storage Management on Small VPS

If you are running OpenClaw on a small VPS with 25-50GB of disk space, storage management matters. Docker can consume disk space silently through accumulated images, containers, and logs.

Check current Docker disk usage:

docker system df

This shows how much space images, containers, volumes, and build cache are using.

Remove unused images and containers:

docker system prune -a

The -a flag removes all unused images, not just dangling ones. This is safe to run — it only removes images that no container is currently using. On a server that has been through several OpenClaw updates, this can reclaim 2-5GB of space from old image versions.

Limit Docker log sizes: Docker container logs can grow without bound. On a small VPS, this can fill the disk. Configure log rotation in /etc/docker/daemon.json:

{
  "log-driver": "json-file",
  "log-opts": {
    "max-size": "10m",
    "max-file": "3"
  }
}

This limits each container's log to 3 files of 10MB each (30MB max per container). Restart Docker after changing this config.

Prune OpenClaw data directory: The data/ directory grows over time with conversation logs, memory entries, and cached responses. Check its size periodically:

du -sh ./data/

If it exceeds a few GB, consider archiving or deleting old conversation logs. OpenClaw includes a data management CLI:

docker exec openclaw openclaw data prune --older-than 30d

This removes conversation data older than 30 days while preserving memory entries and configuration.

Schedule regular cleanup: Add a weekly cron job to prune Docker and OpenClaw data:

0 3 * * 0 docker system prune -f && docker exec openclaw openclaw data prune --older-than 60d

This runs every Sunday at 3 AM, pruning unused Docker resources and removing OpenClaw conversation data older than 60 days.

Building a Custom Image

If neither the standard nor slim image fits your needs, you can build a custom OpenClaw Docker image. The Dockerfile in the OpenClaw GitHub repository supports multi-stage builds and build arguments for customization.

Clone the repository and build:

git clone https://github.com/openclaw/openclaw.git
cd openclaw
docker build -t my-openclaw .

To exclude specific integrations during build, use build arguments:

docker build \
  --build-arg INCLUDE_PUPPETEER=false \
  --build-arg INCLUDE_SHARP=false \
  -t my-openclaw-custom .

You can also create a Dockerfile that extends the official image with pre-installed skills:

FROM openclaw/openclaw:3.23-slim
COPY ./my-skills/ /app/data/skills/
COPY ./my-config.env /app/.env

This creates a custom image with your skills and configuration baked in. It is useful for deploying the same OpenClaw setup across multiple servers — build once, deploy everywhere.

Custom builds are also useful for organizations with strict security policies. You can run the Dockerfile through your CI/CD pipeline with security scanning, pin every dependency version, and push to a private registry. This gives you full control over what runs in your containers.

Frequently Asked Questions

How big is the OpenClaw Docker image?

The OpenClaw Docker image (latest tag) is approximately 850MB-1.1GB compressed (pulled size) and 1.8-2.2GB uncompressed on disk. The exact size varies by version and architecture. The slim tag is approximately 600MB compressed by excluding optional integrations and dev dependencies.

What Docker image tags does OpenClaw publish?

OpenClaw publishes several tags: latest (most recent stable release), version-specific tags like 3.23 and 3.23.1, slim (smaller image without optional integrations), and dev (development builds). Both AMD64 and ARM64 architectures are supported via multi-arch manifests.

How do I reduce OpenClaw Docker storage usage?

Three main approaches: (1) Use the slim tag instead of latest to save 200-400MB. (2) Run docker system prune regularly to remove unused images, containers, and build cache. (3) Limit Docker log sizes in /etc/docker/daemon.json with max-size and max-file options. Also prune old OpenClaw data periodically.

Can I build a custom OpenClaw Docker image?

Yes. OpenClaw's Dockerfile is in the GitHub repository and supports multi-stage builds. You can create a custom image that includes only the integrations you need, pre-installs specific skills, or adds custom configuration. Build with: docker build -t my-openclaw .