linkding Documentation

File: README.md Copy Chapter

Introduction Copy Chapter

linkding is a bookmark manager that you can host yourself.
It's designed be to be minimal, fast, and easy to set up using Docker.

The name comes from:

• link which is often used as a synonym for URLs and bookmarks in common language
• Ding which is German for thing
• ...so basically something for managing your links

Feature Overview:

• Clean UI optimized for readability
• Organize bookmarks with tags
• Bulk editing, Markdown notes, read it later functionality
• Share bookmarks with other users or guests
• Automatically provides titles, descriptions and icons of bookmarked websites
• Automatically archive websites, either as local HTML file or on Internet Archive
• Import and export bookmarks in Netscape HTML format
• Installable as a Progressive Web App (PWA)
• Extensions for Firefox and Chrome, as well as a bookmarklet
• SSO support via OIDC or authentication proxies
• REST API for developing 3rd party apps
• Admin panel for user self-service and raw data access

Demo: https://demo.linkding.link/

Screenshot:

Getting Started Copy Chapter

The following links help you to get started with linkding:

• Install linkding on your own server or check managed hosting options
• Install the browser extension
• Check out community projects, which include mobile apps, browser extensions, libraries and more

Documentation Copy Chapter

The full documentation is now available at linkding.link.

If you want to contribute to the documentation, you can find the source files in the docs folder.

If you want to contribute a community project, feel free to submit a PR.

Contributing Copy Chapter

Small improvements, bugfixes and documentation improvements are always welcome. If you want to contribute a larger feature, consider opening an issue first to discuss it. I may choose to ignore PRs for features that don't align with the project's goals or that I don't want to maintain.

Development Copy Chapter

The application is built using the Django web framework. You can get started by checking out the excellent Django docs. The bookmarks folder contains the actual bookmark application. Other than that the code should be self-explanatory / standard Django stuff 🙂.

Prerequisites Copy Section

• Python 3.13
• uv
• Node.js

Setup Copy Section

Initialize the development environment with:

make init

This sets up a virtual environment using uv, installs NPM dependencies and runs migrations to create the initial database.

Create a user for the frontend:

uv run manage.py createsuperuser --username=joe [email protected]

Run the frontend build for bundling frontend components with:

make frontend

Then start the Django development server with:

make serve

The frontend is now available under http://localhost:8000

Tests Copy Section

Run all tests with pytest:

make test

Linting Copy Section

Run linting with ruff:

make lint

Formatting Copy Section

Format Python code with ruff, Django templates with djlint, and JavaScript code with prettier:

make format

DevContainers Copy Section

This repository also supports DevContainers:

Once checked out, only the following commands are required to get started:

Create a user for the frontend:

uv run manage.py createsuperuser --username=joe [email protected]

Start the Node.js development server (used for compiling JavaScript components like tag auto-completion) with:

make frontend

Start the Django development server with:

make serve

The frontend is now available under http://localhost:8000

File: docs/src/content/docs/admin.md Copy Chapter

title: "Admin" Copy Chapter

This document describes how to make use of the admin app that comes as part of each linkding installation. This is the default Django admin app with some linkding specific customizations.

The admin app provides several features that are not available in the linkding UI:

• User management and user self-management
• Bookmark and tag management, including bulk operations

Linkding administration page Copy Chapter

To open the Admin app, go the Settings view and click on the Admin tab. This should open a new window with the admin app.

Alternatively you can open the URL directly by adding /admin to the URL of your linkding installation.

User management Copy Chapter

Go to the linkding administration page and select Users.
Here you can add and delete users, and change the password of a user.

Once you have added a user you can, if needed, give the user staff status, which means this user can also access the linkding administration page.

This page also allows you to change your own password if necessary.

Bookmark management Copy Chapter

While the linkding UI itself now has a bulk edit feature for bookmarks you can also use the admin app to manage bookmarks or to do bulk operations.

In the main linkding administration page, choose Bookmarks.

First select the bookmarks to operate on:

• Specify a filter to determine which bookmarks to operate on:
  • In the column by username, you can choose to filter for bookmarks for a specific user
  • In the column by is archived, you can choose to filter for bookmarks that are either archived or not
  • In the column by tags, you can choose to filter for specific tags
  • In the search box you can also add a text filter (note that this doesn't use the same search syntax as the linkding UI itself)

Now a list of bookmarks which match your filter is displayed, each bookmark on a separate line.
Each line starts with a checkbox.
Either choose the individual bookmarks you want to do a bulk operation on, or choose the top checkbox to select all shown bookmarks.

Open the "Action" select box to choose the desired bulk operation:

• Delete
• Archive
• Unarchive

Click the button next to the checkbox to execute the operation.

Tag management Copy Chapter

While linkding UI currently only allows to create or assign tags, you can use the admin app to manage your tags. This can be especially useful if you want to clean up your tag collection.

In the main linkding administration page, choose Tags.

Similar to bookmarks management described above you can now specify which tags to operate on by specifying a filter and then selecting the individual tags.

Open the "Action" select box to choose the desired bulk operation:

• Delete
• Delete unused tags - this will only delete the selected tags that are currently not assigned to any bookmark

Click the button next to the checkbox to execute the operation.

Note that deleting a tag does not affect the bookmarks that are tagged with this tag, it only removes the tag from those bookmarks.

File: docs/src/content/docs/api.md Copy Chapter

title: "API" Copy Chapter

The application provides a REST API that can be used by 3rd party applications to manage bookmarks.

Authentication Copy Chapter

All requests against the API must be authorized using an authorization token. The application automatically generates an
API token for each user, which can be accessed through the Settings page.

The token needs to be passed as Authorization header in the HTTP request:

Authorization: Token <Token>

Resources Copy Chapter

The following resources are available:

Bookmarks Copy Section

List

GET /api/bookmarks/

List bookmarks.

Parameters:

• q - Filters results using a search phrase using the same logic as through the UI
• limit - Limits the max. number of results. Default is 100.
• offset - Index from which to start returning results
• modified_since - Filter results to only include bookmarks modified after the specified date (format: ISO 8601, e.g. "2025-01-01T00:00:00Z")
• added_since - Filter results to only include bookmarks added after the specified date (format: ISO 8601, e.g. "2025-05-29T00:00:00Z")
• bundle - Filter results by bundle id to only include bookmarks matched by a given bundle

Example response:

{
  "count": 123,
  "next": "http://127.0.0.1:8000/api/bookmarks/?limit=100&offset=100",
  "previous": null,
  "results": [
    {
      "id": 1,
      "url": "https://example.com",
      "title": "Example title",
      "description": "Example description",
      "notes": "Example notes",
      "web_archive_snapshot_url": "https://web.archive.org/web/20200926094623/https://example.com",
      "favicon_url": "http://127.0.0.1:8000/static/https_example_com.png",
      "preview_image_url": "http://127.0.0.1:8000/static/0ac5c53db923727765216a3a58e70522.jpg",
      "is_archived": false,
      "unread": false,
      "shared": false,
      "tag_names": [
        "tag1",
        "tag2"
      ],
      "date_added": "2020-09-26T09:46:23.006313Z",
      "date_modified": "2020-09-26T16:01:14.275335Z"
    },
    ...
  ]
}

List Archived

GET /api/bookmarks/archived/

List archived bookmarks.

Parameters and response are the same as for the regular list endpoint.

Retrieve

GET /api/bookmarks//

Retrieves a single bookmark by ID.

Check

GET /api/bookmarks/check/?url=https%3A%2F%2Fexample.com

Allows to check if a URL is already bookmarked. If the URL is already bookmarked, the bookmark property in the
response holds the bookmark data, otherwise it is null.

Also returns a metadata property that contains metadata scraped from the website. Finally, the auto_tags property
contains the tag names that would be automatically added when creating a bookmark for that URL.

Example response:

{
  "bookmark": {
    "id": 1,
    "url": "https://example.com",
    "title": "Example title",
    "description": "Example description",
    ...
  },
  "metadata": {
    "title": "Scraped website title",
    "description": "Scraped website description",
    ...
  },
  "auto_tags": [
    "tag1",
    "tag2"
  ]
}

Create

POST /api/bookmarks/

Creates a new bookmark. Tags are simply assigned using their names. Including
is_archived: true saves a bookmark directly to the archive.

If the provided URL is already bookmarked, this silently updates the existing bookmark instead of creating a new one. If
you are implementing a user interface, consider notifying users about this behavior. You can use the /check endpoint
to check if a URL is already bookmarked and at the same time get the existing bookmark data. This behavior may change in
the future to return an error instead.

If the title and description are not provided or empty, the application automatically tries to scrape them from the
bookmarked website. This behavior can be disabled by adding the disable_scraping query parameter to the API request.

Example payload:

{
  "url": "https://example.com",
  "title": "Example title",
  "description": "Example description",
  "notes": "Example notes",
  "is_archived": false,
  "unread": false,
  "shared": false,
  "tag_names": [
    "tag1",
    "tag2"
  ]
}

Update

PUT /api/bookmarks//
PATCH /api/bookmarks//

Updates a bookmark.
When using PUT, at least all required fields must be provided (currently only url).
When using PATCH, only the fields that should be updated need to be provided.
Regardless which method is used, any field that is not provided is not modified.
Tags are simply assigned using their names.

Note that auto tagging rules are applied on every update: tags from
matching rules are merged into tag_names, even if the request does not include that field.

If the provided URL is already bookmarked this returns an error.

Example payload:

{
  "url": "https://example.com",
  "title": "Example title",
  "description": "Example description",
  "tag_names": [
    "tag1",
    "tag2"
  ]
}

Archive

POST /api/bookmarks//archive/

Archives a bookmark.

Unarchive

POST /api/bookmarks//unarchive/

Unarchives a bookmark.

Delete

DELETE /api/bookmarks//

Deletes a bookmark by ID.

Bookmark Assets Copy Section

List

GET /api/bookmarks//assets/

List assets for a specific bookmark.

Example response:

{
  "count": 2,
  "next": null,
  "previous": null,
  "results": [
    {
      "id": 1,
      "bookmark": 1,
      "asset_type": "snapshot",
      "date_created": "2023-10-01T12:00:00Z",
      "content_type": "text/html",
      "display_name": "HTML snapshot from 10/01/2023",
      "status": "complete"
    },
    {
      "id": 2,
      "bookmark": 1,
      "asset_type": "upload",
      "date_created": "2023-10-01T12:05:00Z",
      "content_type": "image/png",
      "display_name": "example.png",
      "status": "complete"
    }
  ]
}

Retrieve

GET /api/bookmarks//assets//

Retrieves a single asset by ID for a specific bookmark.

Download

GET /api/bookmarks//assets//download/

Downloads the asset file.

Upload

POST /api/bookmarks//assets/upload/

Uploads a new asset for a specific bookmark. The request must be a multipart/form-data request with a single part
named file containing the file to upload.

Example response:

{
  "id": 3,
  "bookmark": 1,
  "asset_type": "upload",
  "date_created": "2023-10-01T12:10:00Z",
  "content_type": "application/pdf",
  "display_name": "example.pdf",
  "status": "complete"
}

Delete

DELETE /api/bookmarks//assets//

Deletes an asset by ID for a specific bookmark.

Tags Copy Section

List

GET /api/tags/

List tags.

Parameters:

• limit - Limits the max. number of results. Default is 100.
• offset - Index from which to start returning results

Example response:

{
  "count": 123,
  "next": "http://127.0.0.1:8000/api/tags/?limit=100&offset=100",
  "previous": null,
  "results": [
    {
      "id": 1,
      "name": "example",
      "date_added": "2020-09-26T09:46:23.006313Z"
    },
    ...
  ]
}

Retrieve

GET /api/tags//

Retrieves a single tag by ID.

Create

POST /api/tags/

Creates a new tag.

Example payload:

{
  "name": "example"
}

Delete

DELETE /api/tags//

Deletes a tag by ID.

Bundles Copy Section

List

GET /api/bundles/

List bundles.

Parameters:

• limit - Limits the max. number of results. Default is 100.
• offset - Index from which to start returning results

Example response:

{
  "count": 3,
  "next": null,
  "previous": null,
  "results": [
    {
      "id": 1,
      "name": "Work Resources",
      "search": "productivity tools",
      "any_tags": "work productivity",
      "all_tags": "",
      "excluded_tags": "personal",
      "order": 0,
      "date_created": "2020-09-26T09:46:23.006313Z",
      "date_modified": "2020-09-26T16:01:14.275335Z"
    },
    {
      "id": 2,
      "name": "Tech Articles",
      "search": "",
      "any_tags": "programming development",
      "all_tags": "",
      "excluded_tags": "outdated",
      "order": 1,
      "date_created": "2020-09-27T10:15:30.123456Z",
      "date_modified": "2020-09-27T10:15:30.123456Z"
    },
    ...
  ]
}

Retrieve

GET /api/bundles//

Retrieves a single bundle by ID.

Create

POST /api/bundles/

Creates a new bundle. If no order is specified, the bundle will be automatically assigned the next available order position.

Example payload:

{
  "name": "My Bundle",
  "search": "search terms",
  "any_tags": "tag1 tag2",
  "all_tags": "required-tag",
  "excluded_tags": "excluded-tag",
  "order": 5
}

Update

PUT /api/bundles//
PATCH /api/bundles//

Updates a bundle.
When using PUT, all fields except read-only ones should be provided.
When using PATCH, only the fields that should be updated need to be provided.

Example payload:

{
  "name": "Updated Bundle Name",
  "search": "updated search terms",
  "any_tags": "new-tag1 new-tag2",
  "order": 10
}

Delete

DELETE /api/bundles//

Deletes a bundle by ID.

User Copy Section

Profile

GET /api/user/profile/

User preferences.

Example response:

{
  "theme": "auto",
  "bookmark_date_display": "relative",
  "bookmark_link_target": "_blank",
  "web_archive_integration": "enabled",
  "tag_search": "lax",
  "enable_sharing": true,
  "enable_public_sharing": true,
  "enable_favicons": false,
  "display_url": false,
  "permanent_notes": false,
  "search_preferences": {
    "sort": "title_asc",
    "shared": "off",
    "unread": "off"
  }
}

File: docs/src/content/docs/archiving.md Copy Chapter

title: "Archiving" Copy Chapter

Linkding allows to archive bookmarked web pages as HTML files. This can be useful to preserve the content of a web page in case it goes offline or its content changes. The sections below explain different methods to archive web pages and store them in linkding.

Server-based Archiving Copy Chapter

Linkding can automatically create HTML snapshots whenever a bookmark is added. This feature is only available in the latest-plus Docker image (see Installation), and is automatically active when using that image.

The snapshots are created using singlefile-cli, which effectively runs a headless Chromium instance on the server to convert the web page into a single HTML file. Linkding will also load the uBlock Origin Lite extension into Chromium to attempt to block ads and other unwanted content.

When bookmarking a URL that points directly to a PDF file, linkding will download the PDF instead of creating an HTML snapshot. This happens automatically based on the content type of the URL, and the downloaded PDF will be stored as an asset alongside the bookmark, just like HTML snapshots.

This method is fairly easy to set up, but also has several downsides:

• The Docker image is significantly larger than the base image, as it includes a Chromium installation.
• Running Chromium requires significantly more memory, at least 1 GB of RAM.
• The Docker image is not available for ARM v7 platforms.
• Creating snapshots from a headless browser is not always reliable, for example:
  • It may trigger anti-bot measures on the website.
  • Websites that require login will not show the same content you would see in your browser.

Read on for alternative methods to archive web pages directly from your browser, which do not require the latest-plus Docker image and will save the web page exactly as you see it in your browser.

Using the Singlefile Browser Extension Copy Chapter

Singlefile is a popular browser extension for saving a web page as a single HTML file. By default, the extension saves the file to your local disk, but it can also be configured to send the file to a REST API endpoint. Linkding provides a REST API endpoint for this purpose.

To use the Singlefile extension with linkding, follow these steps:

• Install the Singlefile extension in your browser
• Open the extension's settings
• Under Destination, select upload to a REST Form API
• Under URL enter the URL of your linkding installation, followed by /api/bookmarks/singlefile/ (e.g. https://linkding.example.com/api/bookmarks/singlefile/)
• Under authorization token, enter the REST API token that you can get from your linkding settings page
• Under data field name enter file
• Under URL field name enter url

Now, when you click the Singlefile extension icon, the web page will be saved as a single HTML file and uploaded to your linkding installation.
Note that if a bookmark for that URL does not exist, linkding will automatically create a new bookmark. If a bookmark already exists, the snapshot will be added to the existing bookmark.

Using this method has some downsides, in that you can not provide any additional metadata to the bookmark, such as tags or a description. Read on for how to use the linkding extension directly to create bookmarks with metadata and run the Singlefile extension.

Using the linkding Browser Extension Copy Chapter

The linkding extension allows you to quickly add bookmarks from your browser. It can also integrate with the Singlefile extension to automatically create a snapshot of the web page when adding a bookmark.

To integrate with the Singlefile extension, follow these steps:

• First, install and configure the Singlefile extension as described above so that it uploads files to your linkding installation
• Open the linkding extension settings
• Enable the Run Singlefile after adding new bookmark option
• Save the settings

Now, when you add a bookmark through the linkding extension, it will automatically trigger the Singlefile extension to create a snapshot of the web page, which will then be uploaded to your linkding installation and stored under the newly added bookmark.

Note that when the option is enabled, linkding will not attempt to create an HTML snapshot on the server, even if you are using the latest-plus Docker image. The linkding extension will not trigger Singlefile when updating an existing bookmark. If you want to create a new snapshot for an existing bookmark, you can do so manually by clicking the Singlefile extension icon.

Extension Store Compatibility Copy Section

The linkding and Singlefile extensions communicate using store-specific extension IDs. For the integration to work, both extensions must be installed from the same browser extension store. For example:

• If you install linkding from the Chrome Web Store, install Singlefile from the Chrome Web Store as well
• If you install linkding from Firefox Add-ons, install Singlefile from Firefox Add-ons as well

This is particularly relevant for Microsoft Edge users, as Edge can install extensions from both the Chrome Web Store and the Microsoft Edge Add-ons store. If the extensions are installed from different stores, the automatic Singlefile integration will not work.

File: docs/src/content/docs/auto-tagging.md Copy Chapter

title: "Auto tagging" Copy Chapter

Auto tagging allows to automatically add tags to bookmarks based on predefined rules. This makes categorizing commonly
bookmarked websites easier and faster.

Auto tagging rules can be defined in the profile settings. Each rule maps a URL pattern to one or more tags. For
example:

youtube.com video
reddit.com/r/Music music reddit

When a bookmark is created or updated, the URL of the bookmark is parsed to extract the hostname, path, query
string and fragment. These components are then compared against the patterns defined in the auto tagging rules. If all components
match, the tags associated with the rule are added to the bookmark. Both the bookmark form in the web interface and the
browser extension will show a preview of the tags that will be added based on the auto tagging rules.

The URL matching works like this:

• Hostname Matching: The hostname of the bookmark URL is compared to the hostname in the rule. If the rule does not
  specify a subdomain, it matches all subdomains. For example, a rule with youtube.com will match both
  www.youtube.com and m.youtube.com. If a subdomain is specified in the rule, it will only match that subdomain. For
  example, a rule with gist.github.com will only match gist.github.com.
• Path Matching: The path of the bookmark URL is compared to the path in the rule. If the rule does not specify a
  path, it matches all paths. For example, a rule with reddit.com will match reddit.com/r/music,
  reddit.com/r/gaming, etc. If a path is specified in the rule, it will only match that path and all its subpaths. For
  example, a rule with reddit.com/r/music will match reddit.com/r/music, reddit.com/r/music/new, etc.
• Query String Matching: The query string parameters of the bookmark URL are compared to those in the rule. If the
  rule does not specify any query string parameters, it matches all query strings. If the rule specifies a query string
  it will only match if the bookmark URL contains all the specified query string parameters with their respective
  values.
• Fragment Matching: The URL fragment (part after the # symbol) is also compared when present in a rule. If the rule
  specifies a fragment, it will match any URL whose fragment starts with the specified fragment. For example, a rule with
  example.com/#/projects will match URLs like example.com/#/projects/123 or example.com/#/projects/456.

Note that URL matching currently does not support any kind of wildcards. Rule matching only works based on the URL, not
on the content of the website or any other aspect of the bookmark.

Example Copy Chapter

Consider the following auto tagging rule:

reddit.com/r/Music music reddit

When adding a bookmark for a URL like https://www.reddit.com/r/Music/comments/..., the auto tagging mechanism will:

1. Parse the URL to extract the hostname (www.reddit.com), path (/r/Music/comments/...), and query string (none).
2. Match the hostname against the pattern. The domain reddit.com matches. Since the rule does not specify a subdomain,
   it also matches www.reddit.com.
3. Match the path against the pattern. The path /r/Music also matches the nested path /r/Music/comments/....
4. Match the query string. Since the rule does not specify a query string, it matches all query strings.
5. The tags music and reddit will be added to the bookmark.

File: docs/src/content/docs/backups.md Copy Chapter

title: "Backups" Copy Chapter

Linkding stores all data in the application's data folder.
The full path to that folder in the Docker container is /etc/linkding/data.
As described in the installation docs, you should mount the /etc/linkding/data folder to a folder on your host system.

The data folder contains the following contents that are relevant for backups:

• db.sqlite3 - the SQLite database
• assets - folder that contains HTML snapshots of bookmarks
• favicons - folder that contains downloaded favicons
• previews - folder that contains downloaded preview images

The following sections explain how to back up the individual contents.

Full backup Copy Chapter

linkding provides a CLI command to create a full backup of the data folder. This creates a zip file that contains backups of the database, assets, favicons, and preview images.

:::note
This method assumes that you are using the default SQLite database.
If you are using a different database, such as Postgres, you'll have to back up the database and other contents of the data folder manually.
:::

To create a full backup, execute the following command:

docker exec -it linkding python manage.py full_backup /etc/linkding/data/backup.zip

This creates a backup.zip file in the Docker container under /etc/linkding/data.

To copy the backup file to your host system, execute the following command:

docker cp linkding:/etc/linkding/data/backup.zip backup.zip

This copies the backup file from the Docker container to the current folder on your host system.
Now you can move that file to your backup location.

To restore a backup:

• Extract the zip file in a folder of your new installation.
• Rename the extracted folder to data.
• When starting the Docker container, mount that folder to /etc/linkding/data as explained in the README.
• Then start the Docker container.

Alternative backup methods Copy Chapter

If you can't use the full backup method, this section describes alternatives how to back up the individual contents of the data folder.

SQLite database backup Copy Section

linkding includes a CLI command for creating a backup copy of the database.

:::caution
While the SQLite database is just a single file, it is not recommended to just copy that file.
This method is not transaction safe and may result in a corrupted database.
Use one of the backup methods described below.
:::

:::caution
This method is deprecated and may be removed in the future.
Please use the full backup method described above.
:::

To create a backup, execute the following command:

docker exec -it linkding python manage.py backup /etc/linkding/data/backup.sqlite3

This creates a backup.sqlite3 file in the Docker container under /etc/linkding/data.

To copy the backup file to your host system, execute the following command:

docker cp linkding:/etc/linkding/data/backup.sqlite3 backup.sqlite3

This copies the backup file from the Docker container to the current folder on your host system.
Now you can move that file to your backup location.

To restore the backup, just copy the backup file to the data folder of your new installation and rename it to db.sqlite3. Then start the Docker container.

SQLite database SQL dump Copy Section

Requires SQLite to be installed on your host system.

With this method you create a plain text file with the SQL statements to recreate the SQLite database.
To create a backup, execute the following command in the data folder on your host system:

sqlite3 db.sqlite3 .dump > backup.sql

This creates a backup.sql which you can copy to your backup location.
As this is a plain text file you can also commit it to any revision management system, like git.
Using git, you can commit the changes, followed by a git push to a remote repository.

Exporting bookmarks from the UI Copy Section

This is the least technical option to back up bookmarks, but has several limitations:

• It does not export user profiles.
• It only exports your own bookmarks, not those of other users.
• It does not export URLs of snapshots on the Internet Archive Wayback machine.
• It does not export HTML snapshots of bookmarks. Even if you backup and restore the assets folder, the bookmarks will not be linked to the snapshots anymore.
• It does not export favicons or preview images.

Only use this method if you are fine with the above limitations.

To export bookmarks from the UI, open the general settings.
In the Export section, click on the Download button to download an HTML file containing all your bookmarks.
Then move that file to your backup location.

To restore bookmarks, open the general settings on your new installation.
In the Import section, click on the Choose file button to select the HTML file you downloaded before.
Then click on the Import button to import the bookmarks.

Assets Copy Section

If you are using the HTML snapshots feature, you should also do backups of the assets folder.
It contains the HTML snapshots files of your bookmarks which are referenced from the database.

To back up the assets, then you have to copy the assets folder to your backup location.

To restore the assets, copy the assets folder back to the data folder of your new installation.

Favicons Copy Section

Doing a backup of the icons is optional, as they can be downloaded again.

If you choose not to back up the icons, you can just restore the database and then click the Refresh Favicons button in the general settings.
This will download all missing icons again.

If you want to back up the icons, then you have to copy the favicons folder to your backup location.

To restore the icons, copy the favicons folder back to the data folder of your new installation.

File: docs/src/content/docs/browser-extension.md Copy Chapter

title: "Browser Extension" Copy Chapter

linkding comes with an official browser extension that allows to quickly add bookmarks, and search bookmarks through the browser's address bar. You can get the extension here:

• Mozilla Addon Store
• Chrome Web Store

The extension is open-source as well, and can be found here.

File: docs/src/content/docs/community.md Copy Chapter

title: "Community" Copy Chapter

This section lists community projects around using linkding. If you have a project that you want to share with the linkding community, feel free to submit a PR to add your project to this section.

Mobile and Desktop Apps Copy Chapter

Browser Extensions Copy Chapter

Web and CLI Apps Copy Chapter

Utilities Copy Chapter

Libraries Copy Chapter

Self-Hosting Guides Copy Chapter

File: docs/src/content/docs/how-to.md Copy Chapter

title: "How to" Copy Chapter

Collection of tips and tricks around using linkding.

Using the bookmarklet on Android/Chrome Copy Chapter

This how-to explains the usage of the standard linkding bookmarklet on Android / Chrome.

Chrome on Android does not permit running bookmarklets in the same way you can on a desktop system. There is however a workaround that is explained here.

Note that this only works with Chrome and not with other browsers on Android.

Create a bookmark of your linkding deployment by clicking the star icon which you find in the three dots menu in the top right. Next you have to edit the bookmark. Edit the URL and replace it it with the bookmarklet code of your instance and give it an easy to type name like bm for bookmark or ld for linkding:

javascript:window.open(`http://<YOUR_INSTANCE_HERE>/bookmarks/new?url=${encodeURIComponent(window.location)}&auto_close`)

Now when you are browsing the web and you want to save the current page as a bookmark to your linkding instance simply type bm into the address bar and select it from the results. The bookmarklet code will trigger and you will be redirected so save the current page.

For more info see here: https://paul.kinlan.me/use-bookmarklets-on-chrome-on-android/

Using the PWA (Progressive Web App) to save links using the native share sheet on Android Copy Chapter

• Visit your instance in Chrome (works best) or another Chromium-based web browser.
• A popup should appear (first time only) prompting you to install Linkding as an app. If it doesn't, tap the 3-dot menu then tap "Add to Home screen", then tap "Install".
• Linkding will now show up in Android's native share sheet. Share a link from any app or browser and tap Linkding to save a link.
• Optional: when the share sheet is displayed, tap and hold Linkding, then tap "Pin" to pin it to the top.

Using HTTP Shortcuts app on Android Copy Chapter

Note This allows you to share URL from any app to tag and bookmark it to linkding

• Install HTTP Shortcuts from Play Store or F-Droid.

• Copy the URL of linkding_shortcut.json.

• Open HTTP Shortcuts, tap the 3-dot-button at the top-right corner, tap Import/Export, then tap Import from URL.

• Paste the URL you copied earlier, tap OK, go back, tap the 3-dot-button again, then tap Variables.

• Edit the values of linkding_instance and linkding_api_key.

Try using share button on an app, a new item Send to... should appear on the share sheet. You can also manually share by tapping the shortcut inside the HTTP Shortcuts app itself.

Create a share action on iOS for adding bookmarks to linkding Copy Chapter

This how-to explains how to make use of the app shortcuts iOS app to create a share action that can be used in Safari for adding bookmarks to your linkding instance.

To install the shortcut:

• Download the Shortcut on your iOS device
• Tap the downloaded file, which brings up the Shortcuts app
• Confirm that you want to add the shortcut
• In the shortcut, change https://linkding.mydomain.com to the URL of your linkding instance
• Confirm / close the shortcut

To use the shortcut:

• Open Safari and navigate to the page you want to bookmark
• Tap the share button
• Scroll down and tap "Add To Linkding"
• This opens linkding in a Safari overlay where you can configure the bookmark
• When you're done, tap "Save"
• After the bookmark is saved you can close the overlay

At the bottom of the share sheet there is a button for configuring share actions. You can use this to move the "Add To Linkding" action to the top of the share sheet if you like.

:::note
You can also check the Community section for other pre-made shortcuts that you can use.
:::

Increase the font size Copy Chapter

The font size can be adjusted globally by adding the following CSS to the custom CSS field in the settings:

:root {
  --font-size: 0.75rem;
  --font-size-sm: 0.7rem;
  --font-size-lg: 0.9rem;
}

.bookmark-list {
  line-height: 1.15rem;
}

.tag-cloud {
  line-height: 1.15rem;
}

You can adjust the --font-size, --font-size-sm and --font-size-lg variables to your liking.
Note that increasing the font might also require you to adjust the line-height in certain places to better separate texts from each other.
As an example, the above also increases the font size and line height of the bookmark list and tag cloud.