Linkwarden

Deletes a set of bookmarks and all their preserved copies. Two-step: the first call returns a confirmation token that is bound to exactly this set of ids — adding an id afterwards invalidates it.

Applies the same tag list and/or target collection to a set of links. Cheaper than one update_link per link, but far blunter: it can only set tags and move collections, and the tag list applies to every link in the set. With replace_tags=true the given tags REPLACE whatever each link had, so an empty tag list strips all tags from all of them. With replace_tags=false the tags are added to the existing ones. Either way this needs a confirmation token, because it rewrites many records at once.

Creates a collection. Pass parent_id to nest it under an existing collection. New collections are private; use update_collection to publish one.

Saves a bookmark. Linkwarden fetches the page title itself when no name is given, and queues the page for preservation according to the account defaults (get_current_user shows them). The collection is optional; without one the link lands in "Unorganized". Naming a collection that does not exist creates it. If the account has "prevent duplicate links" enabled, saving a URL twice fails with HTTP 409. Linkwarden does the fetching, so a URL addressing its own loopback, the link-local range or a cloud metadata endpoint is refused here. A private LAN address is accepted by this server, but Linkwarden 2.14 and later refuse to preserve one themselves — the bookmark is created and stays without an archive, so get_link_content will have nothing to return.

Subscribes to an RSS or Atom feed. Linkwarden polls it and files every new entry as a link in the given collection, preserving the pages according to the account defaults. Linkwarden fetches the feed once immediately, so an unreachable feed fails right away. Because that fetch happens on the Linkwarden server, a URL addressing its own loopback or the link-local range is refused here before the request is made. That check covers the feed URL only — Linkwarden creates and preserves a link for every entry the feed contains, and on versions before 2.14 it does not check those addresses at all. Do not subscribe to a feed you do not trust. Linkwarden 2.14 and later apply their own check as well, and it is stricter: the feed URL is resolved and any address on a private or loopback range is refused with "URL resolves to a blocked internal hostname". A feed on the same private network as the instance — a company intranet, another container — therefore cannot be subscribed at all, however legitimate. That refusal comes from Linkwarden, not from here, and no argument changes it. Subscription names must be unique per account, and instances cap the number of subscriptions (20 by default).

Creates tags, or updates the ones that already exist — the underlying route is an upsert keyed on the tag name. This is also the only way to set the per-tag archival overrides, which decide how links carrying the tag get preserved. Note that tags are usually created implicitly by create_link and update_link; use this tool when the archival settings matter, or to create a tag before any link uses it.

Deletes a collection. This cascades: every link inside it, every preserved copy of those pages, and every sub-collection below it are deleted too. Two-step: the first call reports how many links would be lost and returns a confirmation token.

Deletes a bookmark and every preserved copy of the page. Two-step: the first call returns a confirmation token, the second call with that token performs the deletion.

Removes the archived screenshot, PDF, readable text and single-file HTML of a set of links while keeping the bookmarks themselves. Useful to reclaim disk space. Unlike represerve_link this does NOT re-archive anything — use that tool if the copies should be recreated.

Stops polling a feed. Links that were already created from it stay where they are — only the subscription goes away.

Deletes one or more tags. The links keep existing, they just lose the tag. Two-step: the first call returns a confirmation token bound to exactly this set of ids.

Fetches one collection with its link count and the per-member create/update/delete permissions. Use search_links with collection_id to get the links inside it.

Reports which Linkwarden account the configured token belongs to and that account's archival defaults — which formats new links get preserved in, and whether duplicate URLs are rejected. Useful as a connectivity check and before creating links, because the defaults decide what get_link_content will later have to read.

Returns the links Linkwarden shows on its dashboard: the most recently added ones together with everything the account has pinned, deduplicated. A quick "what is going on here" overview — use search_links for anything targeted.

Fetches one bookmark with its tags, collection and which preserved formats exist. Does not include the archived page text — use get_link_content for that.

Returns the readable article text Linkwarden extracted and stored when it preserved the page, so a saved bookmark can be read without fetching the live site. Only the readable format is served: the screenshot, PDF and single-file HTML archives are binary or raw markup and are not useful as text. Long articles are returned in slices — pass the offset from the previous result to continue. If the link has no readable archive, the tool says so and represerve_link can create one. Preservation is asynchronous: Linkwarden queues the page and a worker drives a headless browser over it, which takes minutes. A link created moments ago has no readable archive yet, and that is not an error — get_worker_stats shows the queue.

Fetches one tag with its archival settings. Use search_links with tag_id to get the links carrying it.

Reports how many links are waiting to be preserved, how many succeeded and how many failed, plus the search-index backlog. Use it to find out whether a page requested through represerve_link has been archived yet. Requires the instance administrator account (the id in NEXT_PUBLIC_ADMIN, 1 by default); every other account gets HTTP 403 here. The counts cover the whole instance, not just this account.

Lists every collection the authenticated account owns or is a member of, with its link count. The list is flat: nesting is expressed through parentId, where null means the collection sits at the top level. Linkwarden does not page this route, so all collections come back at once.

Lists the RSS feeds this account subscribes to. Linkwarden polls them and files new entries as links in the configured collection.

Lists the tags of the authenticated account with the number of links each one is attached to. Tags cut across collections. The per-tag archival settings are included: null there means "inherit the account default", which is not the same as false.

Folds several tags into a single new one: every link that carried any of the source tags gets the new tag, and the source tags are deleted. Two things to know before calling this. The new tag is created from scratch, so the name must not already be in use by this account — merging into an existing name fails. And the per-tag archival settings of the source tags are not carried over; set them again with create_tags afterwards if they mattered.

Renames a tag; every link carrying it keeps it. Tag names are unique per account, so renaming a tag to a name that already exists fails — use merge_tags to fold two tags into one instead. Asks a person first; where the client cannot show a dialog, call once to receive a token and again with it.

Has Linkwarden archive the page again. This first DELETES the existing preserved copies and only then re-queues the link, so if the site is gone or now blocks the archiver, the old copies are lost and nothing replaces them. That is why it needs a confirmation token. The work happens in a background worker; get_worker_stats shows the queue.

Searches bookmarks, or lists them when no query is given. This is the way to find links — there is no separate list tool, and the older /links listing route is deprecated upstream. Plain text matches the title, URL, description and tag names of a link. IMPORTANT: the field-filter syntax below only works on instances that run Meilisearch. Linkwarden parses those filters exclusively in its Meilisearch branch; without it the whole query is matched as one literal substring, so `tag:news` searches for the characters "tag:news" and finds nothing. Use the collection_id, tag_id and pinned_only arguments instead — those are applied by the database and work either way. list_collections and list_tags give you the ids. Where Meilisearch is available the filters are: url: name: description: type: collection: tag: pinned: public: before: after: These filters match the WHOLE value, not a substring. `name:Report` does not find a link called "Quarterly Report" — it finds one whose title is exactly "Report". Quote values that contain spaces: name:"Quarterly Report". An empty result from a field filter therefore usually means the value was a fragment, not that the filter is unsupported. Plain text without a filter DOES match substrings, so search for the fragment on its own when unsure. Prefix a filter with ! to negate it, e.g. !tag:archive. pinned: and public: take true or false; before: and after: take a date such as 2026-01-31. If the instance sets SEARCH_FILTER_LIMIT, field filters beyond that count are dropped silently, so prefer few, specific filters. Returns at most 100 links plus a next_cursor for the following page. Article text is not included; use get_link_content for that. Indexing is asynchronous where Meilisearch is used: a link created moments ago is not searchable yet. An empty result straight after a write means the index has not caught up, not that the write failed — get_link by id confirms it exists.

Pins a link to the account's dashboard, or removes the pin. Pins are per account, so this only affects the account the token belongs to. Pinned links can be listed with search_links and pinned_only=true.

Changes a collection. Fields that are not given stay as they are: the tool reads the collection first and merges, because the underlying route rebuilds the member list from the request body and would otherwise remove every collaborator. Only the owner of a collection may update it. To move a collection to the top level pass parent_id=0 — Linkwarden needs an explicit marker for that and ignores null. Setting is_public=true needs a confirmation token: it makes the collection and every link in it readable by anyone who has the URL, without logging in.

Changes a bookmark. Fields that are not given stay as they are: the tool reads the link first and merges, because the underlying route replaces the whole record and would otherwise clear the title, description and every tag. The tags argument REPLACES the tag list — pass the full set you want. Moving a link to another collection only works for the collection owner. Changing the URL is destructive and needs a confirmation token: Linkwarden deletes every preserved copy of the old page (screenshot, PDF, readable text, single-file HTML) and starts over.