# OpenArchiver: self-hosted email archiving with deduplication, hashes and Meilisearch

> OpenArchiver is an AGPL-3.0, Docker Compose deployed archive for Gmail, Microsoft 365, IMAP, PST, EML and mbox sources. It stores messages as .eml with deduplication and encryption, indexes them in Meilisearch, and keeps a hash of every file so later tampering is detectable.

**LogicLabs-OU/OpenArchiver** — An open-source platform for legally compliant email archiving.

- Repository: https://github.com/LogicLabs-OU/OpenArchiver
- Website: https://openarchiver.com
- Stars: 2,391 · Forks: 145
- Language: TypeScript
- License: AGPL-3.0
- Published: 2026-09-28 · Updated: 2026-09-28 · Language: en
- Canonical page: https://hysenlabs.com/projects/logiclabs-ou-openarchiver

## What OpenArchiver solves, and for whom

Mailboxes are not archives. A Gmail or Microsoft 365 tenant is a working store: messages get deleted, retention windows expire, and the provider decides what remains. OpenArchiver exists to keep a separate, permanent copy that you control, on your own server, in a format that outlives the application itself. The README calls this a "permanent, tamper-proof record of your communication history, free from vendor lock-in," and the storage decision backs that up: messages are written as standard .eml files rather than rows in a proprietary database.

The audience is narrower than "anyone with email." This is for an operator who is willing to run PostgreSQL, Valkey and Meilisearch next to the application, and who has a reason to keep the data local. The README lists Google Workspace, Microsoft 365, generic IMAP, PST files, zipped .eml files and mbox files as ingestion sources, so the tool fits two situations that look different but share the same need: a company that wants its own copy of a cloud mailbox, and an individual or small team holding a pile of PST and mbox exports from a mail client. The live demo at demo.openarchiver.com is the fastest way to see the interface before committing to a deployment.

## How ingestion, storage and search fit together

OpenArchiver is a pnpm monorepo with apps/ and packages/ at the top level, and the runtime splits into three roles that the package.json scripts name explicitly: ingestion, indexing and scheduler. The scheduler (packages/backend/dist/jobs/schedulers/sync-scheduler.js) drives continuous synchronization, and the .env.example sets its cadence through SYNC_FREQUENCY, which defaults to '* * * * *'. The ingestion worker pulls messages from the configured source, and the indexing worker writes them into Meilisearch. BullMQ on Redis, with Valkey used as the Redis service in the Docker Compose deployment, carries jobs between those stages.

Storage is where the design gets opinionated. Every message lands as an .eml file, compressed and deduplicated, encrypted at rest, on either the local filesystem or an S3-compatible backend such as AWS S3 or MinIO. Alongside the file, a hash of the email and its attachments goes into the metadata database, which is what makes alteration detectable after the fact. The README says each archived email carries an "Integrity Report" indicating whether the files are original. PostgreSQL holds metadata, users and the audit trail; the README describes that trail as immutable and as recording who accessed what and when.

Two configuration knobs reveal the trade-offs the authors hit. ARCHIVE_DRAFTS is off by default, and the .env.example explains why in unusual detail: providers that give every auto-save its own identity fill the archive with revisions of a message that was never sent, while servers that keep one Message-ID from draft to sent would archive the draft first and then discard the real message as a duplicate. File imports ignore the setting and archive everything the file contains. INGESTION_WORKER_CONCURRENCY controls how many mailbox jobs run at once, capped at 32, and the .env.example warns that the per-mailbox parallelism multiplies with it for memory purposes.

## OpenArchiver install and first setup with Docker Compose

The README gives a four-step installation. Docker and Docker Compose are the prerequisites, and the stated memory floor is 4GB of RAM, or 2GB if PostgreSQL, Redis (Valkey) and Meilisearch run as external instances. Clone the repository and enter it:

```bash
git clone https://github.com/LogicLabs-OU/OpenArchiver.git
cd OpenArchiver
```

Copy the example environment file. The README is direct that you must edit it, and that .env.example is the place to read for how to set it up:

```bash
cp .env.example .env
```

The settings that matter on a first run are APP_URL, which the backend uses for CORS and which forms the OAuth redirect URI, and ORIGIN, which the .env.example says should always be set to the value of APP_URL. If you plan to connect a Google Workspace or Microsoft 365 mailbox, register {APP_URL}/api/v1/oauth/callback with the provider exactly as written.

Start the stack. This pulls the pre-built images and runs the frontend, backend, database and search services in the background:

```bash
docker compose up -d
```

The web interface is then reachable on port 3000, which docker-compose.yml maps from PORT_FRONTEND, defaulting to 3000. After logging in, the real work begins: configure an ingestion source. The README links separate guides for Google Workspace, Microsoft 365 and generic IMAP, and the same interface takes PST, zipped .eml and mbox file imports. Expect the first bulk import of a large mailbox to run for a while, since ingestion and indexing are queued asynchronously rather than done inline.

## Where OpenArchiver falls short

The most important limitation is stated by the project itself. Under Compliance & Retention, the README lists legal holds as "(TBD)". Retention policies that delete on a schedule are documented; holds that prevent deletion during litigation are not. For an organisation whose main reason for archiving is eDiscovery, that is the feature that matters most, and it is not there yet. Treat any legal-hold requirement as unmet until the project says otherwise.

Resource behaviour is the second constraint. The indexing worker starts with a heap cap set by INDEXING_WORKER_MAX_OLD_SPACE_MB, defaulting to 2048 in package.json, and the .env.example notes that per-mailbox parallelism multiplies with INGESTION_WORKER_CONCURRENCY for memory. A 4GB host is the documented floor, not a comfortable target, and a first import of several large mailboxes is the workload that will find the ceiling.

Third, the README's configuration section is thin by design. It defers to .env.example, and the deployment section assumes Docker Compose. Nothing in the README documents a rollback path, a backup procedure for the Postgres volume, or a supported way to migrate between local and S3 storage after messages exist. If you need a vendor to call when the archive will not start, this is the wrong tool. The docker-compose.yml comments also show the kind of failure you can hit: an unset REDIS_PASSWORD once expanded to a bare --requirepass, Valkey refused to start, and the application failed against a cache that had never come up, which reads as an application fault rather than a missing variable.

## OpenArchiver compared with Mailpiler and Mail Archiver

The closest open-source comparison is Mailpiler, which people also search for. Mailpiler is a long-standing archiver built around its own storage and indexing design, and it is typically deployed as a dedicated archiving appliance with its own database and search stack. OpenArchiver's difference in approach is the file format and the pluggable backend: messages are kept as .eml on the local filesystem or in S3-compatible object storage, so the archive is readable with ordinary tools even if the application is gone. That is a deliberate bet on portability over a tightly integrated store.

The comparison with Mail Archiver is about scope rather than format. OpenArchiver's README covers ingestion from Google Workspace, Microsoft 365, IMAP, PST, zipped .eml and mbox, plus deduplication, encryption at rest, hashing, an audit trail and retention policies. If your requirement is a smaller, simpler mailbox copy, the extra services here (PostgreSQL, Valkey, Meilisearch) are overhead you will pay for on every upgrade. If your requirement is a defensible record with verifiable file integrity, the hash-and-Integrity-Report design is the reason to pick this one over a plain IMAP sync into a folder.

## Licence and the cost of staying current

OpenArchiver is licensed AGPL-3.0, and the repository's package.json carries "SEE LICENSE IN LICENSE file" for the workspace root. The AGPL matters if you modify the code and let users interact with it over a network: the licence's network clause is the part to read with your own counsel, and this article does not give legal advice. Running the pre-built logiclabshq/open-archiver image as a self-hosted archive for your own organisation is the case the README describes.

The upgrade cost is mostly the stack, not the application. A docker compose pull followed by docker compose up -d moves the application image, but PostgreSQL, Valkey and Meilisearch are separate containers with their own data volumes, and the README does not document a supported upgrade or rollback procedure for them. The release history shows active movement: v0.5.1 added reindexing and an indexing admin panel, v0.5.2 added advanced search and bulk deletion, and v0.6.0 added two-factor authentication and OAuth mailbox ingestion. The last push to the repository was on 2026-09-17, so the codebase is being worked on, but the README does not promise backward compatibility between releases. Pin the image tag rather than tracking latest if you want a predictable upgrade.

## Conclusion

Adopt OpenArchiver if you want the archive on your own hardware, need .eml files you can read without the application, and can run Postgres, Valkey and Meilisearch alongside it. Do not adopt it if you need a supported legal hold workflow today, since the README marks that feature TBD, or if you cannot give the indexing worker more than 2GB of heap. Before committing, verify the hash and Integrity Report behaviour on your own messages, confirm the OAuth callback URI at {APP_URL}/api/v1/oauth/callback is registered with your provider exactly as written, and read .env.example in full because the README defers all configuration to it.

## FAQ

### What is the best free email archiving software for home use?

The README describes OpenArchiver as an open-source, self-hosted platform under AGPL-3.0, and it can be run on a local machine with Docker Compose and at least 4GB of RAM. Whether it is the best fit for a home setup depends on whether you are willing to run PostgreSQL, Valkey and Meilisearch alongside it.

### What are the key differences between Mail Archiver and Open Archiver?

OpenArchiver stores messages as standard .eml files on the local filesystem or on S3-compatible object storage, and it covers ingestion from Google Workspace, Microsoft 365, IMAP, PST, zipped .eml and mbox sources. The README does not describe Mail Archiver, so a feature-by-feature comparison is not possible from this material.

### What does "open archive" mean in OpenArchiver?

In this project the word refers to the archive being open in two senses: the source is published under AGPL-3.0, and archived messages are stored as standard .eml files rather than in a proprietary format. The README frames this as keeping a permanent record "free from vendor lock-in."

### How does OpenArchiver compare with piler?

The README does not mention piler, so a direct comparison cannot be made from this material. What the README does state is that OpenArchiver keeps messages as .eml files on the local filesystem or S3-compatible object storage, which is the design choice to weigh against any other archiver.

### How does OpenArchiver compare with bichon?

The README does not mention bichon, so this comparison cannot be answered from the available material. OpenArchiver's documented ingestion sources are IMAP, Google Workspace, Microsoft 365, PST, zipped .eml and mbox.

## Sources

- [License: AGPL-3.0](https://github.com/LogicLabs-OU/OpenArchiver/blob/main/LICENSE)
- [LogicLabs-OU/OpenArchiver on GitHub](https://github.com/LogicLabs-OU/OpenArchiver)
- [Project website](https://openarchiver.com)
- [README](https://github.com/LogicLabs-OU/OpenArchiver/blob/main/README.md)
- [Releases](https://github.com/LogicLabs-OU/OpenArchiver/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/logiclabs-ou-openarchiver