---
title: "Migrate from Open WebUI on Mac: Get Your Data Out of the Volume"
description: "Your models were never inside Open WebUI. Your conversations were. Here is how to get them off a Docker volume on macOS before you tear the container down."
date: 2026-08-10
author: "Ben Racicot"
tags: ["Open WebUI", "Migration", "Docker", "Ollama", "macOS", "Local LLM"]
type: "article"
canonical: "https://modelpiper.com/blog/migrate-from-open-webui-mac"
---

# Migrate from Open WebUI on Mac: Get Your Data Out of the Volume

> Your models were never inside Open WebUI. Your conversations were. Here is how to get them off a Docker volume on macOS before you tear the container down.

## TL;DR

Leaving Open WebUI is two independent jobs, and conflating them is the mistake. The models were never Open WebUI's: they live in whatever backend it pointed at, usually Ollama. Everything Open WebUI owns, chats, knowledge bases and accounts, is inside a Docker volume at /app/backend/data, which on macOS lives in the Docker VM rather than on your filesystem.

Open WebUI is a front end. It does not run models: its docs describe pointing it at Ollama or an OpenAI-compatible endpoint, and Docker is the officially supported and recommended way to run it, with Python and Kubernetes documented as alternatives.

That layering is the whole shape of the migration. If you try to "move Open WebUI" as one thing you will get confused, because the two halves live in completely different places and only one of them is actually at risk.

## What does Open WebUI actually hold?

Your conversations, prompts, knowledge-base documents and their embeddings, and your user accounts. All of it persists in a single Docker volume named open-webui, mounted inside the container at /app/backend/data, per the quick-start command in Open WebUI's own documentation. Delete the container without dealing with that volume and you have not lost anything yet. Delete the volume and you have.

What it does not hold is the models. Those belong to the backend. If you were running the usual Mac setup, they are in Ollama's store, and that is a completely separate migration with its own guide.

## The macOS problem nobody mentions

On a Mac, Docker runs inside a Linux virtual machine. So the path that docker volume inspect reports as the volume's mountpoint is a path inside that VM, not a folder on your Mac, and you cannot open it in Finder or cd to it in Terminal. This is the step where most Mac migrations stall, and it is not an Open WebUI issue.

The way across the boundary is to have Docker do the copying for you, either out of the running container or out of the volume directly. Both are one command and both are in the steps below. What does not work, and what people try first, is navigating to the mountpoint path. It does not exist on your side of the VM.

## Do the reversible half first

Before any container work, use Open WebUI's own interface while it is still running. Export the conversations you care about, and pull down any documents you uploaded to a knowledge base if you no longer have the originals elsewhere.

This matters more than the volume backup, because an application-level export gives you readable files. A volume archive gives you a database in a layout that is Open WebUI's, is version-specific, and is only useful for restoring into Open WebUI. Take both. Use the readable one.

## The models are a different job

Whatever Open WebUI was pointed at still has your models after Open WebUI is gone, untouched. If that was Ollama, the weights are sitting in a content-addressed store as sha256-named blobs, which is its own recovery problem with [its own walkthrough](/blog/migrate-from-ollama-mac). Do not start it until the Open WebUI data is safely off the volume, because the two jobs share nothing and interleaving them is how you lose track of what you have finished.

The order that works: export from the UI, archive the volume, then deal with the backend, then tear down the container and the volume.

## Getting off the stack entirely

Plenty of people running this setup on a Mac are running three things to get one thing: Docker for the container, Ollama for the inference, and Open WebUI for the window. That stack makes complete sense on a home server with several users, which is what Open WebUI is built for. On one Mac used by one person it is a lot of moving parts for a chat window.

If that is the situation, the replacement is a single native app rather than a smaller stack, and the containers and the second process both go away. [The native options](/blog/ollama-no-docker-mac) are worth reading before you pick one, because more than one of them is reasonable.

## Landing in ToolPiper

ToolPiper is a native Mac app that bundles the runner, so there is no container and no separate model server. The engine is upstream llama-server embedded directly, build b10068, unmodified, and models are plain named GGUF files in `~/Library/Application Support/ToolPiper/models/`. Nothing sits in a volume you need a command to read.

On the data question that this whole page is about: your chats live in the app on your Mac, not in a database inside a VM. And if you are keeping Ollama around during the transition, ToolPiper will connect to it as a backend so both libraries are usable from one interface while you decide.

The free tier is the whole runner: unlimited GGUF downloads, multi-model switching, a local OpenAI-compatible API, embeddings, developer tokens, all speech including transcription, text-to-speech, voice cloning and push-to-talk dictation, browser automation, and an MCP server with over 420 tools. Local RAG over your files is the $10 Pro tier, which is the closest equivalent to Open WebUI's knowledge bases and the one thing here that is not free.

Where Open WebUI stays the better choice, plainly: several people sharing one instance, a machine that is not a Mac, or a setup you reach from other devices on your network. It is genuinely open source, its local-by-default posture is real, and none of that is true of us. ToolPiper is macOS 26 or newer on Apple Silicon, one machine, one person.

A note on cost, because this is the one axis where the comparison is not about money. Open WebUI charges nothing and neither do we for the runner. What differs is what you have to keep running. The backend underneath Open WebUI is usually Ollama, and that stack does now have a free versus paid line, because Ollama Cloud is a priced product sitting beside the free local one. [Where that line falls](/compare/is-ollama-free).

## Steps

### 1. Export from the interface while it still runs

Open Open WebUI in the browser and export the conversations you want to keep, plus any uploaded documents you no longer have copies of. This is the only step that produces readable files rather than a database, so it is the one worth doing carefully. Do it before touching Docker.

### 2. Confirm what the volume is called

Run `docker volume ls`. The quick-start command names it `open-webui`, but a compose file may have prefixed it with the project name. Get the exact name before the next step, because backing up the wrong volume looks identical to backing up the right one.

### 3. Archive the volume to your Mac

Do not chase the mountpoint path from `docker volume inspect`; on macOS it is inside the Docker VM. Have a throwaway container do the copy instead: `docker run --rm -v open-webui:/data -v "$PWD":/backup alpine tar czf /backup/open-webui-backup.tar.gz -C /data .` That leaves a single archive in your current folder, on your side of the VM.

### 4. Verify the archive is not empty

Run `tar tzf open-webui-backup.tar.gz | head` and check the size. An empty or tiny archive means the volume name was wrong or the container had already been removed along with its data. Finding that out now costs a minute; finding it out later costs everything.

### 5. Deal with the models separately

Your weights are in whatever backend Open WebUI pointed at and are not affected by anything above. If that was Ollama, work through the blob extraction on its own, after this is finished, rather than mixing the two jobs.

### 6. Tear it down

With the export and the verified archive in hand: `docker rm -f open-webui`, then `docker volume rm open-webui` once you are certain. Removing the container alone leaves the volume, which is a common way to think you reclaimed space and not have.

## FAQ

### Where does Open WebUI store my chats?

In a Docker volume. The documented quick-start command mounts a volume named open-webui at /app/backend/data inside the container, and everything the app owns persists there: conversations, prompts, knowledge-base documents and their embeddings, and user accounts. Removing the container does not remove the volume.

### Why can I not find the Open WebUI data folder on my Mac?

Because Docker on macOS runs inside a Linux virtual machine, so the mountpoint that docker volume inspect reports is a path in that VM and not a folder on your Mac. There is nothing to navigate to in Finder. Copy the data out with a throwaway container instead, which is the standard way across that boundary.

### Do I lose my models if I remove Open WebUI?

No. Open WebUI does not run models. It points at Ollama or an OpenAI-compatible endpoint, and the weights belong to that backend. Removing the container and its volume affects your conversations and knowledge bases, not your models, which stay exactly where they were.

### Can I import my Open WebUI history into another app?

Not directly. The volume archive is an Open WebUI database in an Open WebUI layout, useful for restoring into Open WebUI and not much else. No local AI app reads another's history. That is why the first step is exporting the conversations you care about from the interface, while it is still running, into files you can actually read.

### Do I need Docker to run Open WebUI?

It is the officially supported and recommended path, and the docs also document Python (pip, uv, conda, venv) and Kubernetes. So Docker is not the only way, but it is the way the project points you at, and the one nearly every Mac guide assumes.

### Is a native Mac app actually simpler than this stack?

For one person on one Mac, yes: Docker plus a model server plus a web UI is three processes to get a chat window, and a native app is one. For several people sharing an instance, or reaching it from other devices, Open WebUI is the right shape and a single-user desktop app is not a replacement for it. Pick on which of those describes you.