ArchiveBox

Built by ArchiveBox

Save the web pages that matter to you, before they disappear.

Productivity

About

What it does

ArchiveBox is your personal Internet Archive. Feed it URLs, bookmarks or browser history and it saves complete copies of each page: HTML, PDF, screenshot, text, media and more.

Your archive stays on your own storage in open formats, so it remains readable for decades, even if the original sites vanish.

Highlights

  • Saves HTML, PDF, screenshots, WARC, media and text
  • Import from bookmarks, browser history, RSS and Pocket
  • Scheduled archiving of feeds and pages
  • Web UI, CLI and REST API
  • Open, durable formats on your own storage

Who it's for

Researchers, journalists and collectors who can’t afford to lose a link.

Readme

from the project's repository

Show the full readme from GitHub

▶️ Quickstart | Demo | GitHub | Documentation | Info & Motivation | Community

   

ArchiveBox is a self-hosted app that lets you preserve content from websites in a variety of formats.

We aim to make your data immediately useful, and kept in formats that other programs can read directly. As output, we save standard HTML, PNG, PDF, TXT, JSON, WARC, SQLite, all guaranteed to be readable for decades to come. ArchiveBox also has a CLI, REST API, and webhooks so you can set up integrations with other services.

Without active preservation effort, everything on the internet eventually disappears or degrades.

ArchiveBox is an open source tool that lets organizations & individuals archive both public & private web content while retaining control over their data. It can be used to save copies of bookmarks, preserve evidence for legal cases, backup photos from FB/Insta/Flickr or media from YT/Soundcloud/etc., save research papers, and more...

➡️ Get ArchiveBox with pip install archivebox>=0.9.0rc0' on Linux/macOS, or via Docker ⭐️ on Linux/macOS.

Once installed, you can interact with it through the: Browser Extension, CLI, self-hosted web interface, Python API, or filesystem.

📥 You can feed ArchiveBox URLs one at a time, or schedule regular imports from your bookmarks or history, social media feeds or RSS, link-saving services like Pocket/Pinboard, our Browser Extension, and more.
See Input Formats for a full list of supported input formats...

It saves snapshots of the URLs you feed it in several redundant formats.
It also detects any content featured inside pages & extracts it out into a folder:

  • 🌐 HTML/Any websites ➡️ original HTML+CSS+JS, singlefile HTML, screenshot PNG, PDF, WARC, title, article text, favicon, headers, ...
  • 🎥 Social Media/News ➡️ post content TXT, comments, title, author, images, ...
  • 🎬 YouTube/SoundCloud/etc. ➡️ MP3/MP4s, subtitles, metadata, thumbnail, ...
  • 💾 Github/Gitlab/etc. links ➡️ clone of GIT source code, README, images, ...
  • ✨ and more, see Output Formats below...

You can run ArchiveBox as a Docker web app to manage these snapshots, or continue accessing the same collection using the uv-installed CLI, Python API, and SQLite3 APIs. All the ways of using it are equivalent, and provide matching features like adding tags, scheduling regular crawls, viewing logs, and more...

🛠️ ArchiveBox uses standard tools like Chrome, wget, & yt-dlp, and stores data in ordinary files & folders.
(no complex proprietary formats, all data is readable without needing to run ArchiveBox)

The goal is to sleep soundly knowing the part of the internet you care about will be automatically preserved in durable, easily accessible formats for decades after it goes down.

📦  Install ArchiveBox using your preferred method: docker / uv / brew / apt / etc. (see full Quickstart below).

Key Features

Quickstart

🖥  Supported OSs: Ubuntu, macOS, Docker   👾  CPUs: amd64 (x86_64), arm64

✳️  Easy Setup

See below for more usage examples using the CLI, Web UI, or filesystem/SQL/Python to manage your archive.

See below for more usage examples using the CLI, Web UI, or filesystem/SQL/Python to manage your archive.

See below for more usage examples using the CLI, Web UI, or filesystem/SQL/Python to manage your archive. See setup.sh for the source code of the uv install shortcut. See "Against curl | sh as an install method" blog post for my thoughts on the shortcomings of this install method.

🛠  Package Manager Setup

See below for more usage examples using the CLI, Web UI, or filesystem/SQL/Python to manage your archive. See the uv tool documentation for more details about this installation method.

See below for more usage examples using the CLI, Web UI, or filesystem/SQL/Python to manage your archive. See the homebrew-archivebox repo for more details about this distribution.

Warning: These are contributed by external volunteers and may lag behind the official uv and Docker channels.

🎗  Other Options

Warning: These are contributed by external volunteers and may lag behind the official Docker and uv channels.

For more discussion on third-party hosting options see here: Issue #531.

➡️  Next Steps

Usage

⚡️  CLI Usage

ArchiveBox commands can be run in a terminal directly on your host, or via Docker/Docker Compose.
(depending on how you chose to install it above)

mkdir -p ~/archivebox/data   # create a new data dir anywhere
cd ~/archivebox/data         # IMPORTANT: cd into the directory

# archivebox [subcommand] [--help]
archivebox version
archivebox help

# equivalent: docker compose run --rm archivebox [subcommand] [--help]
docker compose run --rm archivebox help

# equivalent: docker run -it -v $PWD:/data archivebox/archivebox:dev [subcommand] [--help]
docker run -it -v $PWD:/data archivebox/archivebox:dev help
ArchiveBox Subcommands
  • archivebox help/version to see the list of available subcommands / currently installed version info
  • archivebox setup/init/config/status/shell/manage to administer your collection
  • archivebox add/schedule to pull in fresh URLs from bookmarks/history/RSS/etc.
  • archivebox list/update/remove to manage existing Snapshots in your collection

Open http://admin.archivebox.localhost:5797/admin/ to create the first admin and finish web setup. Use http://web.archivebox.localhost:5797 for the public UI. ➡️ Advanced: archivebox manage createsuperuser remains available for creating accounts from the CLI. Set BASE_URL to change the public base domain. The default auto mode uses web. and admin. subdomains on *.localhost, but one host for ordinary DNS names. BIND_ADDR only controls the local listen address. For more info, see our Usage: Web UI wiki. ➡️ Optional: Change permissions to allow non-logged-in users

Snapshot caching follows each snapshot's saved PERMISSIONS, including inherited defaults and snapshot overrides. Public content can be cached by browsers and shared proxies/CDNs; private and unlisted content uses Cache-Control: private so only the user's browser can cache it. Both retain normal artifact cache lifetimes and validators for fast repeat viewing. Authentication handoffs are not stored. Changing permissions does not revoke copies already cached under the previous policy; purge any affected shared cache when needed.

[!TIP] Whether in Docker or not, ArchiveBox commands work the same way, and can be used to access the same data on-disk. For example, you could run the Web UI in Docker Compose, and run one-off commands with uv-installed ArchiveBox.

For more info, see our Docker wiki. ➡️

Overview

Input Formats: How to pass URLs into ArchiveBox for saving

  • From the official ArchiveBox Browser Extension
    Provides realtime archiving of browsing history or selected pages from Chrome/Chromium/Firefox/Safari browsers.

  • From the official ArchiveBox macOS Desktop App or iOS Mobile App Save directly from the Share menu or Siri/Shortcuts to your server.

  • From manual imports of URLs from RSS, JSON, CSV, TXT, SQL, HTML, Markdown, etc. files
    ArchiveBox supports injesting URLs in any text-based format.

  • From manually exported browser history or browser bookmarks (in Netscape format)
    Instructions: Chrome, Firefox, Safari, IE, Opera, and more...

  • From URLs visited through a MITM Proxy with archivebox-proxy
    Provides realtime archiving of all traffic from any device going through the proxy.

  • From bookmarking services or social media (e.g. Twitter bookmarks, Reddit saved posts, etc.)
    Instructions: Pocket, Pinboard, Instapaper, Shaarli, Delicious, Reddit Saved, Wallabag, Unmark.it, OneTab, Firefox Sync, and more...

# archivebox add --help
archivebox add 'https://example.com/some/page'
archivebox add --depth=1 --plugins=parse_rss_urls "file://$HOME/Downloads/some_feed.xml"
archivebox add --depth=1 'https://news.ycombinator.com#2020-12-12'
echo 'http://example.com' | archivebox add
echo 'any text with <a href="https://example.com">urls</a> in it' | archivebox add

# if using Docker, add -i when piping stdin:
# echo 'https://example.com' | docker run -v $PWD:/data -i archivebox/archivebox:dev add
# if using Docker Compose, add -T when piping stdin / stdout:
# echo 'https://example.com' | docker compose run --rm -T archivebox add

See the Usage: CLI page for documentation and examples.

It also includes a built-in scheduled import feature with archivebox schedule, handled by the same orchestrator that powers archivebox server, so you can pull in URLs from RSS feeds and websites regularly without a separate cron container.

Output Formats: What ArchiveBox saves for each URL

For each web page added, ArchiveBox creates a Snapshot folder and preserves its content as ordinary files inside the folder (e.g. HTML, PDF, PNG, JSON, etc.).

It uses all available methods out-of-the-box, but you can disable extractors and fine-tune the configuration as-needed.

data/archive/users/{username}/snapshots/{YYYYMMDD}/{domain}/{Snapshot.id}/

Configuration

ArchiveBox can be configured via environment variables, by using the archivebox config CLI, or by editing ./ArchiveBox.conf.

The configuration is documented here: Configuration Wiki, and loaded from: archivebox/config/.

Dependencies

To achieve high-fidelity archives in as many situations as possible, ArchiveBox depends on a variety of 3rd-party libraries and tools that specialize in extracting different types of content.

Under-the-hood, ArchiveBox uses Django to power its Web UI, Django Ninja for the REST API, and SQlite + the filesystem to provide fast & durable metadata storage w/ deterministic upgrades.

ArchiveBox bundles industry-standard tools like Google Chrome, wget, yt-dlp, readability, etc. internally, and its operation can be tuned, secured, and extended as-needed for many different applications.

These optional subdependencies used for archiving sites include:

You don't need to install every dependency by hand. ArchiveBox resolves every extractor dependency through abxpkg: it uses a compatible host installation when one is already available, and otherwise installs and manages the dependency for you.

Installing directly on Windows without Docker or WSL/WSL2/Cygwin is not officially supported (I cannot respond to Windows support tickets), but some advanced users have reported getting it working.

Archive Layout

All of ArchiveBox's state (SQLite DB, content, config, logs, etc.) is stored in a single folder per collection.

Data folders can be created anywhere (~/archivebox/data or $PWD/data as seen in our examples), and you can create as many data folders as you want to hold different collections. All archivebox CLI commands are designed to be run from inside an ArchiveBox data folder, starting with archivebox init to initialize a new collection inside an empty directory.

The on-disk layout is optimized to be easy to browse by hand and durable long-term. The main index is a standard index.sqlite3 database in the root of the data folder (it can also be exported as static JSON/HTML). Snapshot data is organized by user, date, domain, and UUID under data/archive/users/.

Each snapshot subfolder includes static metadata and plain extractor output files. Current releases do not create top-level data/archive/TIMESTAMP projections; legacy timestamp directories are migrated into the user-scoped tree by archivebox update --migrate-only.

Static Archive Exporting

You can export your index as static HTML using archivebox list (so you can view it without an ArchiveBox server).

The paths in the static exports are relative, make sure to keep them next to your ./archive folder when backing them up or viewing them.

Caveats

Archiving Private Content

If you're importing pages with private content or URLs containing secret tokens you don't want public (e.g Google Docs, paywalled content, unlisted videos, etc.), you may want to disable some of the extractor methods to avoid leaking that content to 3rd party APIs or the public.

Security Risks of Viewing Archived JS

Archived JavaScript is untrusted content. The default SERVER_SECURITY_MODE=auto uses isolated subdomains with full replay on *.localhost, and a one-domain no-JS replay policy on ordinary public or LAN hostnames. Choose safe-subdomains-fullreplay only when wildcard DNS and TLS are configured. See the Security Overview and Issue #239 for details.

Working Around Sites that Block Archiving

For various reasons, many large sites (Reddit, Twitter, Cloudflare, etc.) actively block archiving or bots in general. There are a number of approaches to work around this.

Saving Multiple Snapshots of a Single URL

ArchiveBox can preserve multiple snapshots of the same URL. The default ONLY_NEW=True skips URLs already in the collection; use --no-only-new when you intentionally want another snapshot.

Each re-archive creates a distinct Snapshot row for the same URL:

The button in the Admin UI performs the same explicit re-archive.

Storage Requirements

Because ArchiveBox is designed to ingest a large volume of URLs with multiple copies of each URL stored by different 3rd-party tools, it can be quite disk-space intensive. There are also some special requirements when using filesystems like NFS/SMB/FUSE.

Screenshots

Background & Motivation

ArchiveBox aims to enable more of the internet to be saved from deterioration by empowering people to self-host their own archives. The intent is for all the web content you care about to be viewable with common software in 50 - 100 years without needing to run ArchiveBox or other specialized software to replay it.

Vast treasure troves of knowledge are lost every day on the internet to link rot. As a society, we have an imperative to preserve some important parts of that treasure, just like we preserve our books, paintings, and music in physical libraries long after the originals go out of print or fade into obscurity.

Whether it's to resist censorship by saving news articles before they get taken down or edited, or just to save a collection of early 2010's flash games you loved to play, having the tools to archive internet content enables to you save the stuff you care most about before it disappears.

The balance between the permanence and ephemeral nature of content on the internet is part of what makes it beautiful. I don't think everything should be preserved in an automated fashion--making all content permanent and never removable, but I do think people should be able to decide for themselves and effectively archive specific content that they care about, just like libraries do. Without the work of archivists saving physical books, manuscrips, and paintings we wouldn't have any knowledge of our ancestors' history. I believe archiving the web is just as important to provide the same benefit to future generations.

ArchiveBox's stance is that duplication of other people's content is only ethical if it:

  • A. doesn't deprive the original creators of revenue and
  • B. is responsibly curated by an individual/institution.

In the U.S., libraries, researchers, and archivists are allowed to duplicate copyrighted materials under "fair use" for private study, scholarship, or research. Archive.org's non-profit preservation work is covered under fair use in the US, and they properly handle unethical content/DMCA/GDPR removal requests to maintain good standing in the eyes of the law.

As long as you A. don't try to profit off pirating copyrighted content and B. have processes in place to respond to removal requests, many countries allow you to use software like ArchiveBox to ethically and responsibly archive any web content you can view. That being said, ArchiveBox is not liable for how you choose to operate the software. You must research your own local laws and regulations, and get proper legal counsel if you plan to host a public instance (start by putting your DMCA/GDPR contact info in FOOTER_INFO and placing branding overrides in your collection's fixed custom_templates/ directory).

Comparison to Other Projects

Check out our community wiki for a list of alternative web archiving tools and orgs.

ArchiveBox gained momentum in the internet archiving industry because it uniquely combines 3 things:

  • it's distributed: users own their data instead of entrusting it to one big central provider
  • it's future-proof: saving in multiple formats and extracting out raw TXT, PNG, PDF, MP4, etc. files
  • it's extensible: with powerful APIs, flexible storage, and a big community adding new extractors regularly

ArchiveBox tries to be a robust, set-and-forget archiving solution suitable for archiving RSS feeds, bookmarks, or your entire browsing history (beware, it may be too big to store), including private/authenticated content that you wouldn't otherwise share with a centralized service like Archive.org.

Not all content is suitable to be archived on a centralized, publicly accessible platform. Archive.org doesn't offer the ability to save things behind login walls for good reason, as the content may not have been intended for a public audience. ArchiveBox exists to fill that gap by letting everyone save what they have access to on an individual basis, and to encourage decentralized archiving that's less succeptible to censorship or natural disasters.

By having users store their content locally or within their organizations, we can also save much larger portions of the internet than a centralized service has the disk capacity to handle. The eventual goal is to work towards federated archiving where users can share portions of their collections with each other, and with central archives on a case-by-case basis.

ArchiveBox differentiates itself from similar self-hosted projects by providing both a comprehensive CLI interface for managing your archive, a Web UI that can be used either independently or together with the CLI, and a simple on-disk data format that can be used without either.

If you want better fidelity for very complex interactive pages with heavy JS/streams/API requests, check out ArchiveWeb.page and ReplayWeb.page.

If you want more bookmark categorization and note-taking features, check out Memex, Hoarder, LinkWarden, Archivy, or LinkAce.

If you need more advanced recursive spider/crawling ability beyond --depth=1, check out Browsertrix, Photon, or Scrapy and pipe the outputted URLs into ArchiveBox.

For more alternatives, see our list here...

ArchiveBox is neither the highest fidelity nor the simplest tool available for self-hosted archiving, rather it's a jack-of-all-trades that tries to do most things well by default. We encourage you to try these other tools made by our friends if ArchiveBox isn't suited to your needs.

Internet Archiving Ecosystem

Documentation

We use the ArchiveBox GitHub Wiki for documentation.

There is also a mirror available on Read the Docs (though it's sometimes outdated).

✏️ You can submit docs changes & suggestions in our dedicated repo ArchiveBox/docs.

Getting Started

Advanced

Developers

More Info

ArchiveBox Development

All contributions to ArchiveBox are welcomed! Check our issues and Roadmap for things to work on, and please open an issue to discuss your proposed implementation before working on things! Otherwise we may have to close your PR if it doesn't align with our roadmap.

For low hanging fruit / easy first tickets, see: ArchiveBox/Issues #good first ticket #help wanted.

Python API Documentation: https://docs.archivebox.io/dev/apidocs/

Internal Architecture Diagrams: https://github.com/ArchiveBox/ArchiveBox/wiki/ArchiveBox-Architecture-Diagrams

Setup the dev environment

1. Setup the monorepo

First make sure you have uv installed: https://docs.astral.sh/uv/getting-started/installation/

git clone https://github.com/ArchiveBox/monorepo
cd monorepo
./bin/setup.sh

# activate the monorepo venv, then cd into archivebox
source .venv/bin/activate
cd archivebox

Repos included in monorepo setup:

2. Option A: Install the Python, JS, and system dependencies directly on your machine
# Install ArchiveBox runtime dependencies
mkdir -p data && cd data
archivebox init
archivebox install         # detect and install all extractor dependencies

# Run the development server w/ autoreloading (but no bg workers)
archivebox server --debug --reload 0.0.0.0:5797

# Run the production server (with bg workers but no autoreloading)
archivebox server 0.0.0.0:5797
2. Option B: Build the docker container and use that for development instead
# Optional: develop via docker by mounting the code dir into the container
# if you edit e.g. ./archivebox/core/models.py on the docker host, runserver
# inside the container will reload and pick up your changes
./bin/build_docker.sh dev

# Run the development server w/ autoreloading (but no bg workers)
docker run -it -v $PWD/data:/data -v $PWD/archivebox:/app/archivebox -p 5797:5797 archivebox/archivebox:dev server --init --debug --reload 0.0.0.0:5797

# Run the production server (with bg workers but no autoreloading)
docker run -it -v $PWD/data:/data -v $PWD/archivebox:/app/archivebox -p 5797:5797 archivebox/archivebox:dev server --init

# (remove the --reload flag and add the --nothreading flag when profiling with the django debug toolbar)
# When using --reload, make sure any files you create can be read by the user in the Docker container, eg with 'chmod a+rX'.

Common development tasks

See the ./bin/ folder and read the source of the bash scripts within. You can also run all these in Docker. For more examples see the GitHub Actions CI/CD tests that are run: .github/workflows/*.yaml.

Run in DEBUG mode
# set up persistent DEBUG=True for all runs
archivebox config --set DEBUG=True

# OR you can run a dev server with DEBUG=True in a few ways:
archivebox server --debug --reload 0.0.0.0:5797
# or
archivebox server --debug 0.0.0.0:5797
# or
env DEBUG=True daphne -b 0.0.0.0 -p 5797 archivebox.core.asgi:application

https://stackoverflow.com/questions/1074212/how-can-i-see-the-raw-sql-queries-django-is-running

Install and run a specific GitHub branch
Use a Pre-Built Image

If you're looking for the latest dev Docker image, it's often available pre-built on Docker Hub, simply pull and use archivebox/archivebox:dev.

docker pull archivebox/archivebox:dev
docker run archivebox/archivebox:dev version
# verify the BUILD_TIME and COMMIT_HASH in the output are recent
Build Branch from Source

You can also build and run any branch yourself from source, for example to build & use dev locally:

# docker-compose.yml:
services:
    archivebox:
        image: archivebox/archivebox:dev
        build: 'https://github.com/ArchiveBox/ArchiveBox.git#dev'
        ...

# or with plain Docker:
docker build -t archivebox:dev https://github.com/ArchiveBox/ArchiveBox.git#dev
docker run -it -v $PWD:/data -p 5797:5797 archivebox:dev

# or with uv:
uv tool install --python 3.13 --upgrade 'git+https://github.com/ArchiveBox/ArchiveBox.git@dev'
archivebox install
Run the linters / tests
./bin/lint.sh
./bin/test.sh

(uses ruff, pyright, ty, and pytest -s)

Make DB migrations, enter Django shell, other dev helper commands
# generate the database migrations after changes to models.py
archivebox manage makemigrations

# enter a python shell or a SQL shell
cd path/to/test/data/
archivebox shell
archivebox manage dbshell

# generate a graph of the ORM models
brew install graphviz
uv run --with pydot --with graphviz archivebox manage graph_models -a -o orm.png
open orm.png

# list all models with field db info and methods
archivebox manage list_model_info --all --signature --db-type --field-class

# print all django settings
archivebox manage print_settings
uv run --with pyyaml archivebox manage print_settings --format=yaml

# autogenerate an admin.py from given app models
archivebox manage admin_generator core > core/admin.py

# dump db data to a script that re-populates it
archivebox manage dumpscript core > scripts/testdata.py
archivebox manage reset core
archivebox manage runscript testdata

# resetdb and clear all data!
archivebox manage reset_db

# use django-tui to interactively explore commands
# ensure django-tui is in INSTALLED_APPS: core/settings.py
uv run --with django-tui archivebox manage tui
Contributing a new extractor

Extractors are maintained in a separate repo here: https://github.com/ArchiveBox/abx-plugins (included in monorepo setup).

Copy a similar plugin as a template to modify, then open a new PR to add it in that repo.

Build the docs, pip package, and docker image

(Normally CI takes care of this, but these scripts can be run to do it manually)

./bin/build.sh

# or individually:
./bin/build_docs.sh
./bin/build_pip.sh
./bin/build_docker.sh

Further Reading