# Shiori: Self-Hosted Go Bookmark Manager with Offline Archiving

> Shiori is a bookmark manager written in Go, distributed as a single binary, that archives the readable content of saved pages offline by default. It targets developers and self-hosters who want a Pocket-style experience on their own infrastructure.

**go-shiori/shiori** — Simple bookmark manager built with Go

- Repository: https://github.com/go-shiori/shiori
- Stars: 11,657 · Forks: 632
- Language: Go
- License: MIT
- Published: 2026-09-21 · Updated: 2026-09-21 · Language: en
- Canonical page: https://hysenlabs.com/projects/go-shiori-shiori

## A Pocket Alternative for Your Own Server

Pocket is a cloud-based bookmarking service that saves pages to Mozilla's servers. Shiori is designed as a direct functional alternative, described in the README as a "simple clone of Pocket", except that all data stays on the host the operator controls.

The appeal is straightforward. A developer who bookmarks research, code references, and technical articles may not want that reading history on a third-party server. Shiori runs on hardware the operator owns, stores nothing externally, and exposes both a command-line interface and a web interface. The trade-off is that the operator takes on hosting, updates, and backup responsibilities that Pocket handles automatically.

The target audience is developers who are comfortable running a small Go web service and managing a database, and who want persistent, searchable, offline-accessible bookmarks without creating an account on an external platform.

## Single Binary, Four Database Backends

Shiori compiles to a single binary, which means there is no runtime dependency on a separate application server or framework installation. The binary starts a web server, handles HTTP requests, and manages bookmarks directly.

For storage, Shiori supports sqlite3, PostgreSQL, MariaDB, and MySQL. The README lists these as the four supported options, giving operators flexibility to use an existing database or start with the simplest option (sqlite3, which requires no separate server process) and migrate later.

The repository includes a development docker-compose.yaml that illustrates how the database connections work. The file shows the key environment variable for database configuration:

```yaml
# SHIORI_DATABASE_URL: mysql://shiori:shiori@(mariadb)/shiori?charset=utf8mb4
# SHIORI_DATABASE_URL: postgres://shiori:shiori@postgres/shiori?sslmode=disable
```

The `SHIORI_DATABASE_URL` variable accepts a full connection string, and the format differs by backend. Leaving it unset defaults to sqlite3 stored in the data directory.

The Dockerfile shows the server starts with a single command:

```bash
CMD ["server"]
```

The default port is 8080, set through the `PORT` environment variable, and the data directory is controlled by `SHIORI_DIR`.

## Configuring Shiori with Docker Compose

The repository's development docker-compose.yaml exposes the key configuration surface. A minimal deployment uses two environment variables: one for the data directory and one for the port.

The docker-compose shows the shiori service with these settings:

```yaml
ports:
  - "8080:8080"
volumes:
  - "./dev-data:/srv/shiori"
environment:
  SHIORI_DIR: /srv/shiori
```

The `SHIORI_DIR` variable tells the binary where to store its data files, including the SQLite database if that backend is used. Port 8080 is the default, and the Dockerfile confirms it with `ENV PORT=8080`.

For a production setup, the README refers to the docs/ folder and the grocy.info links page for community-maintained guides covering configurations beyond the basics. The pre-built Docker images are referenced through the GitHub container registry label in the Dockerfile:

```
org.opencontainers.image.source="https://github.com/go-shiori/shiori"
```

The `.goreleaser.yaml` file in the repository suggests that pre-built binaries are distributed through GoReleaser, so platform-specific binaries are available for download rather than requiring a Go compilation step.

## Offline Archiving: How Shiori Saves Page Content

The README states that, where possible, Shiori parses the readable content of a saved page and creates an offline archive by default. This means adding a bookmark does not merely record a URL: Shiori fetches the page, extracts the main article text, and stores it. If the original URL later becomes unavailable, the archived version remains readable.

The repository includes a screenshot showing two display modes: a reader mode that renders the extracted text cleanly, and an archive mode that shows a captured version of the full page. The comparison screenshot (referenced in the README as mode-comparison) illustrates the difference between the cleaned-up readable text and the archived original layout.

The go.mod shows that the readable content extraction uses the go-readability library (github.com/go-shiori/go-readability), and the archiving layer uses go-epub and the WARC format library (github.com/go-shiori/warc). These are all first-party libraries maintained by the same organization, which means the archiving behavior is tightly integrated rather than delegated to an external service.

This offline archiving is a meaningful functional difference from simple link-saving tools. It adds storage cost (each archived page takes disk space proportional to its content size) but provides resilience against link rot.

## CLI and Web Interface Side by Side

Shiori provides both a command-line application and a web interface. The README positions these as two separate usage modes for the same underlying binary. A developer who prefers to add bookmarks from the terminal can use the CLI; anyone who prefers a browser-based UI can use the web interface on port 8080.

The web extension for Firefox and Chrome is listed in the README but marked BETA. It exists as a separate repository (github.com/go-shiori/shiori-web-ext) and provides browser-level bookmark saving. The BETA designation means the extension may have unresolved issues and should be evaluated before depending on it.

The bookmark management feature set covers the basics: add, edit, delete, and search. Import is supported from Netscape Bookmark files (the standard export format used by most browsers) and from Pocket. Export back to Netscape Bookmark format is also available. The go.mod shows the image handling library (github.com/disintegration/imaging) and the epublication library (github.com/go-shiori/go-epub) in the dependencies, suggesting the offline archive can be exported in ebook format, though the README does not describe this in detail.

## Where Shiori Falls Short

Shiori's README is intentionally brief: it lists features and points to the docs/ folder for everything else. What the README does not cover is also informative. There is no mention of full-text search across archived content (as opposed to metadata search). There is no mobile application described; access on mobile would be through the web interface in a browser. RTL language support is not mentioned for the web interface.

The web extension is still in BETA after several years in the repository. That suggests browser-level integration has not reached the same maturity as the core server and CLI. Anyone planning to use Shiori primarily through the browser extension should test it carefully against their target browser version before committing to it.

Database migrations during version upgrades are not described in the README. With four supported backends and multiple versions (v1.7.4 in January 2025, v1.8.0 in September 2025), schema changes between releases are likely. The docs/ folder presumably covers migration, but the README does not provide a migration command or procedure.

For teams wanting shared bookmark collections with multiple user accounts and role-based access, the README gives no indication of such a feature. Shiori appears designed for a single user or a small group on shared infrastructure.

## Maintenance Status, License, and Pocket as the Baseline

The last push to the repository was on July 10, 2026. The most recent stable release was v1.8.0, published in September 2025. The project uses Go 1.25.1 as its minimum Go version, as stated in go.mod.

Shiori is released under the MIT license. MIT places no conditions on use, modification, or distribution other than retaining the license notice. This makes it suitable for both personal use and integration into commercial products.

Pocket is the stated design reference in the README. Pocket is a hosted service operated by Mozilla that syncs bookmarks across devices, provides a mobile app, and handles infrastructure. The difference in approach is fundamental: Pocket offloads all storage, sync, and archiving to a cloud service that the user does not control, while Shiori puts those functions on an operator-managed server. Pocket offers device sync and a mobile app out of the box. Shiori does not mention either capability in the README.

For a developer who already runs a home server or cloud VPS and wants to keep bookmark data local, Shiori provides the core functionality of Pocket without the external account dependency. For a developer who wants device sync, a native mobile app, or a zero-maintenance service, the self-hosted model introduces ongoing operational work that Pocket avoids.

## Conclusion

Shiori works well for individual developers or small teams who want to bookmark and archive web content without depending on a cloud service. The single-binary distribution keeps deployment simple. The offline archiving feature makes saved content readable when the original page goes offline, but the web extension is still marked BETA, so browser integration should be tested before relying on it. Before deploying, confirm your preferred database backend is supported and review the docs/ folder for configuration options beyond what the README covers.

## FAQ

### How do you use Shiori to manage bookmarks?

Shiori provides both a command-line interface and a web interface on port 8080. Bookmarks can be added, edited, deleted, and searched through either interface. The README refers to the docs/ folder for detailed usage instructions.

### Can Shiori import bookmarks from Pocket?

Yes. The README lists importing bookmarks from Pocket as a supported feature. It also supports importing from Netscape Bookmark files, the standard export format used by most browsers.

### What database does Shiori use by default?

Shiori defaults to sqlite3 when no SHIORI_DATABASE_URL environment variable is set, which requires no separate database server. It also supports PostgreSQL, MariaDB, and MySQL for larger deployments.

## Sources

- [go-shiori/shiori on GitHub](https://github.com/go-shiori/shiori)
- [Issues](https://github.com/go-shiori/shiori/issues)
- [License: MIT](https://github.com/go-shiori/shiori/blob/master/LICENSE)
- [README](https://github.com/go-shiori/shiori/blob/master/README.md)
- [Releases](https://github.com/go-shiori/shiori/releases)

---

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