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: Quote values that contain spaces, e.g. collection:"Read later". 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.

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.

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.

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.

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.

Fetches one tag with its archival settings. Use search_links with tag_id to get the links carrying 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.

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

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.

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.

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.

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.

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.

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.

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.

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.

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.

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

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.

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.

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.

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.

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.

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.

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 a feed that is unreachable or points at a private address is rejected right away. Subscription names must be unique per account, and instances cap the number of subscriptions (20 by default).

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