# denho/faved: a self-hosted bookmark manager built around nested tags > Faved is an MIT-licensed bookmark manager that runs on PHP 8, SQLite and Apache, stores everything locally, and organises links through customisable nested tags. This review covers its tag model, its Docker install, its import path from Chrome and Pocket, and where it stops being the right tool. **denho/faved** — Free open-source bookmark manager with customisable nested tags. Super fast and lightweight. All data is stored locally. - Repository: https://github.com/denho/faved - Website: https://faved.to - Stars: 1,318 · Forks: 73 - Language: TypeScript - License: MIT - Published: 2026-09-10 · Updated: 2026-09-10 · Language: en - Canonical page: https://hysenlabs.com/projects/denho-faved ## What denho/faved solves, and for whom Browser bookmark managers break down in a predictable way. A folder tree is a single hierarchy, so a link about a Python HTTP client has to live under either Python or Networking, and the moment you pick one the other becomes unfindable. Faved's answer is nested tags with an optional tag rollup, which the README describes as including items from child tags. That one setting changes the retrieval model: a parent tag stops being a container and becomes a query over everything beneath it. The project targets people whose collections have outgrown a sidebar. The README states it is built to handle large collections and advanced use cases, and the feature list backs that up: bulk deleting, refetching and tagging, duplicate detection on add, and a choice of card, list or table layouts with configurable fields. If you have forty bookmarks, this is more machinery than you need. If you have four thousand and cannot remember whether you filed something under a tool or a language, the tag model is the reason to look. Two audiences are served by two different paths. Self-hosters get a Docker image with no external dependencies, and the README says all data is stored locally. Everyone else can sign up at app.faved.to, which the README describes as zero setup with automatic backups and encryption. The code in denho/faved is the self-hosted half. The hosted service is a separate product, and nothing about its internals is visible in this repository. ## How the nested tag model and the PHP backend fit together The repository layout is a conventional PHP application with a React frontend compiled into it. The README lists controllers, models, framework, utils and views on the server side, frontend for React sources, public for web-accessible files, and storage for the database. The stack named in the credits is TypeScript, React, Tailwind, Shadcn UI and Vite on the front, PHP 8, SQLite and Apache on the back. There is no separate database server to run, which is why the Docker image can be described as having no external dependencies. That SQLite choice is the load-bearing decision. It makes installation trivial and backup a file copy, and it caps how far you can scale writes. A personal bookmark manager with one or two concurrent users sits comfortably inside those limits. A shared instance for a team, with many simultaneous writes and a large collection, is the case where a single-file database starts to look like the wrong substrate. The README does not discuss concurrency or database size limits, so treat that as an open question to test rather than a documented property. Tag nesting appears to be a data-model concern rather than a folder convention, because the README presents tag rollup as a toggle and offers per-tag colour and description. That means a tag is an entity with attributes, not a string on a bookmark, and the hierarchy is stored as relationships. The README lists icons for tags as coming soon, so the current customisation surface is colour and description only. Automatic fetching of titles, descriptions and preview images is the other server-side job. It happens when a bookmark is added, and bulk refetching exists for when it fails or when a page changes. The README does not state how fetch failures are surfaced, which matters if you bulk-import a large file over a slow connection. ## Installing Faved with Docker and saving a first bookmark The README points self-hosters at the installation page in the docs rather than putting steps in the repository root, so the compose file in the repository is the concrete artifact to work from. It defines a single service named apache-php running the denho/faved image, with four named volumes and two published ports. The host port defaults to 8080 through the PORT variable and the TLS port defaults to 8443 through SSL_PORT, so the compose file below is the one from the repository, unmodified. ```yaml name: faved services: apache-php: container_name: faved-web-app image: denho/faved restart: unless-stopped working_dir: /var/www/html volumes: - temp-data:/tmp/ - storage:/var/www/html/storage/ - apache-conf:/etc/apache2/sites-enabled/ - certbot-conf:/etc/letsencrypt/ ports: - "${PORT:-8080}:80" - "${SSL_PORT:-8443}:443" ``` Bring it up in the background. The restart policy in the file is unless-stopped, so the container comes back after a reboot without further configuration. ```bash docker compose up -d ``` After that, open http://localhost:8080 in a browser. If port 8080 is already taken, set PORT before running compose, for example PORT=9090 docker compose up -d, and use that port instead. The storage volume is the one that holds the SQLite database, mounted at /var/www/html/storage/, and it is the volume you need to back up. For saving links, the README offers three routes: a Chrome extension, a browser bookmarklet that works without extensions, and Apple Shortcuts for the iOS and macOS share sheet. The bookmarklet is the one that works in any browser, which is the point of it. The README does not print the bookmarklet code in the repository; it links to a documentation page named Using browser bookmarklet, which is where the snippet lives. Copy it from there rather than reconstructing it. Once a link is saved, the server fetches its title, description and preview image automatically. Duplicate detection runs at add time, so saving the same URL twice is meant to be caught rather than silently creating a second entry. ## Importing from Chrome, Pocket and Raindrop.io Migration is where most bookmark tools lose people, and Faved's pitch here is specific. The README states that imports from Chrome, Safari, Firefox and Edge preserve the original folder structure thanks to nested tags. That is the interesting claim: a browser export is a folder tree, and the stated behaviour is that each folder becomes a tag in a hierarchy rather than a flat label. If that holds, an existing Chrome profile lands as a browsable tag tree instead of a wall of identically named folders. The README also lists migration from Raindrop.io, Pocket and other tools with collections, tags and other data retained. It does not specify which file format is expected for each source, and it does not describe what happens to items that fail to map. That gap is worth attention before you delete anything. The safe sequence is to import into Faved, spot-check a few deep folders and a few tagged items, and only then retire the old tool. Bulk actions matter after an import, because a large file will contain entries you no longer want. The README lists bulk deleting, refetching and tagging. Refetching is the useful one for an old export: titles and preview images that were captured years ago, or never captured at all, can be pulled again in a batch. The README does not state rate limits or how long a large refetch takes, so plan it as a background operation rather than something you watch. ## Where Faved is the wrong choice The clearest limitation is the runtime. Faved is a PHP 8 application served by Apache, with a React frontend built on top of it. That is a heavier operational footprint than a static single-page app, and it is heavier than a browser-native bookmark sync that costs you nothing to run because the browser vendor hosts it. If your requirement is that bookmarks follow you across devices with zero servers, Faved's self-hosted path is not that. The hosted option exists, but then you are trusting someone else's instance, which is the opposite of the local-storage argument. SQLite is the second constraint. It is excellent for a single-user instance and awkward for anything with meaningful write concurrency. The README does not publish limits, benchmarks or guidance on collection size, so anyone planning a shared deployment is working without documented numbers. The feature list also contains an honest gap. Automated tagging is marked as planned, and tag icons are marked as coming soon. Neither is a defect, but neither should be counted as present when comparing against tools that already do them. Finally, consider what happens when the project stops. The code is MIT-licensed, so you can fork and maintain it, and the SQLite file is readable without the application. That is a genuinely better position than a proprietary service, but it still assumes someone in your organisation can read PHP. If nobody can, the licence is theoretical comfort. ## How Faved differs from Raindrop.io and browser sync Raindrop.io is the obvious comparison because Faved explicitly offers migration from it. Raindrop is a hosted service with clients across platforms; Faved is a codebase you run yourself, with a hosted option alongside it. The practical difference is where the data sits and who patches the server. With Raindrop you get someone else's uptime and someone else's outage. With Faved's Docker image you get the storage volume and the upgrade responsibility. The README does not compare the two feature by feature, so the honest framing is that Faved trades operational convenience for control and for the nested-tag model. Browser-native sync is the other alternative, and it is closer than it looks on cost. Chrome, Firefox and Safari all sync bookmarks for free, and Faved imports from all of them. The difference is the organisational model: browser sync gives you folders, Faved gives you tags with hierarchy, rollup, colour and description, plus instant search and configurable sorting. If folders are sufficient, browser sync wins on effort. If you have been fighting folders, that is the specific problem Faved was built for. A third option is a plain read-it-later tool in the Pocket mould. Faved supports that workflow through the share sheet and bookmarklet, but its centre of gravity is a library you curate, not a queue you drain. ## Maintenance, licensing and upgrade cost The repository is not archived, and its last push was on 2026-08-05. The most recent release is v2.10.0, tagged the same day, following v2.9.1 on 2026-06-23 and v2.9.0 on 2026-03-30. That is a release cadence of roughly one minor version per quarter, with patch releases between. For a self-hosted tool, that is a manageable upgrade rhythm: you are not chasing a daily-moving target. Upgrading means pulling a new image and restarting the service. Because the database lives in the storage volume rather than in the container, the container can be replaced without touching your data, which is the standard benefit of the volume layout in the compose file. The README links to a dedicated Updating page in the docs, and that page is the authority on whether any release needs a manual step; the repository itself does not describe migrations. The licence is MIT. In practical terms that permits commercial use, modification and redistribution provided the copyright notice and permission notice are included, and it comes with no warranty. This is not legal advice, and the LICENSE file in the repository is the text that governs. One consequence worth noting for a self-hoster: because the licence is permissive and the storage format is a local SQLite file, you are not locked in by licensing or by data format. You can export your way out, and the README's import section implies the reverse is also supported for several tools. ## Conclusion Adopt Faved if you keep thousands of links, want nested tags instead of a flat folder tree, and are willing to run a PHP 8, SQLite and Apache stack from the denho/faved image. Skip it if you need a hosted service with a support contract, or if you want your bookmarks to live inside your browser's own sync account. Before committing, verify that the storage and apache-conf volumes persist the way you expect, that your import file matches the documented format, and that your backup routine covers the SQLite file rather than only the container. ## FAQ ### What is Faved? Faved is a free, open-source bookmark manager with customisable nested tags, distributed under the MIT licence. It is built to handle large collections, and the README states that all data is stored locally when you self-host it. ### Is Faved legit? The source code is public under the MIT licence at denho/faved, and the README links to a live demo at demo.faved.to as well as a hosted signup. You can run the self-hosted Docker image and inspect the code yourself rather than taking the hosted service on trust. ### What does the name Faved mean? The README does not explain the name. It is not defined anywhere in the repository material, so any reading of it as a word is an interpretation rather than something the project states. ## Sources - [denho/faved on GitHub](https://github.com/denho/faved) - [License: MIT](https://github.com/denho/faved/blob/main/LICENSE) - [Project website](https://faved.to) - [README](https://github.com/denho/faved/blob/main/README.md) - [Releases](https://github.com/denho/faved/releases) --- Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/denho-faved