diff --git a/admin/database/database.go b/admin/database/database.go
index 88d6e58830f7..161157b52a9e 100644
--- a/admin/database/database.go
+++ b/admin/database/database.go
@@ -300,6 +300,8 @@ type DB interface {
 	InsertProjectAccessRequest(ctx context.Context, opts *InsertProjectAccessRequestOptions) (*ProjectAccessRequest, error)
 	DeleteProjectAccessRequest(ctx context.Context, id string) error
 
+	// FindBookmarks returns the bookmarks in a project that are visible to the user: their own plus shared and default ones.
+	// resourceKind and resourceName are optional filters; when both are empty, all bookmarks in the project are returned.
 	FindBookmarks(ctx context.Context, projectID, resourceKind, resourceName, userID string) ([]*Bookmark, error)
 	FindBookmark(ctx context.Context, bookmarkID string) (*Bookmark, error)
 	FindDefaultBookmark(ctx context.Context, projectID, resourceKind, resourceName string) (*Bookmark, error)
diff --git a/admin/database/postgres/postgres.go b/admin/database/postgres/postgres.go
index 6b600f47c36e..715e2a3b8ae8 100644
--- a/admin/database/postgres/postgres.go
+++ b/admin/database/postgres/postgres.go
@@ -2852,11 +2852,23 @@ func (c *connection) DeleteProjectAccessRequest(ctx context.Context, id string)
 	return checkDeleteRow("project access request", res, err)
 }
 
-// FindBookmarks returns a list of bookmarks for a user per project
+// FindBookmarks returns the bookmarks in a project that are visible to the user.
+// resourceKind and resourceName are optional filters; when empty, they are not applied.
 func (c *connection) FindBookmarks(ctx context.Context, projectID, resourceKind, resourceName, userID string) ([]*database.Bookmark, error) {
+	qry := `SELECT * FROM bookmarks WHERE project_id = $1 AND (user_id = $2 OR shared = true OR "default" = true)`
+	args := []any{projectID, userID}
+	if resourceKind != "" {
+		args = append(args, resourceKind)
+		qry += fmt.Sprintf(" AND resource_kind = $%d", len(args))
+	}
+	if resourceName != "" {
+		args = append(args, resourceName)
+		qry += fmt.Sprintf(" AND lower(resource_name) = lower($%d)", len(args))
+	}
+	qry += " ORDER BY lower(display_name), created_on"
+
 	var res []*database.Bookmark
-	err := c.getDB(ctx).SelectContext(ctx, &res, `SELECT * FROM bookmarks WHERE project_id = $1 and resource_kind = $2 and lower(resource_name) = lower($3) and (user_id = $4 or shared = true or "default" = true)`,
-		projectID, resourceKind, resourceName, userID)
+	err := c.getDB(ctx).SelectContext(ctx, &res, qry, args...)
 	if err != nil {
 		return nil, parseErr("bookmarks", err)
 	}
@@ -2903,7 +2915,7 @@ func (c *connection) UpdateBookmark(ctx context.Context, opts *database.UpdateBo
 	if err := database.Validate(opts); err != nil {
 		return err
 	}
-	res, err := c.getDB(ctx).ExecContext(ctx, `UPDATE bookmarks SET display_name=$1, description=$2, url_search=$3, shared=$4 WHERE id=$5`,
+	res, err := c.getDB(ctx).ExecContext(ctx, `UPDATE bookmarks SET display_name=$1, description=$2, url_search=$3, shared=$4, updated_on=now() WHERE id=$5`,
 		opts.DisplayName, opts.Description, opts.URLSearch, opts.Shared, opts.BookmarkID)
 	return checkUpdateRow("bookmark", res, err)
 }
diff --git a/admin/server/bookmarks.go b/admin/server/bookmarks.go
index c166ff2c5f8e..07d813b9ee34 100644
--- a/admin/server/bookmarks.go
+++ b/admin/server/bookmarks.go
@@ -12,7 +12,8 @@ import (
 	"google.golang.org/protobuf/types/known/timestamppb"
 )
 
-// ListBookmarks server returns the bookmarks for the user per project
+// ListBookmarks returns the bookmarks in a project that are visible to the user: their own plus shared and default ones.
+// The resource kind and name are optional filters; when both are empty, all bookmarks in the project are returned.
 func (s *Server) ListBookmarks(ctx context.Context, req *adminv1.ListBookmarksRequest) (*adminv1.ListBookmarksResponse, error) {
 	claims := auth.GetClaims(ctx)
 	// Error if authenticated as anything other than a user
@@ -20,6 +21,25 @@ func (s *Server) ListBookmarks(ctx context.Context, req *adminv1.ListBookmarksRe
 		return nil, status.Error(codes.Unauthenticated, "not authenticated as a user")
 	}
 
+	if req.ResourceName != "" && req.ResourceKind == "" {
+		return nil, status.Error(codes.InvalidArgument, "resource_kind is required when resource_name is set")
+	}
+
+	proj, err := s.admin.DB.FindProject(ctx, req.ProjectId)
+	if err != nil {
+		return nil, err
+	}
+
+	permissions := claims.ProjectPermissions(ctx, proj.OrganizationID, proj.ID)
+	if proj.Public {
+		permissions.ReadProject = true
+		permissions.ReadProd = true
+	}
+
+	if !permissions.ReadProject {
+		return nil, status.Error(codes.PermissionDenied, "does not have permission to read the project")
+	}
+
 	bookmarks, err := s.admin.DB.FindBookmarks(ctx, req.ProjectId, req.ResourceKind, req.ResourceName, claims.OwnerID())
 	if err != nil {
 		return nil, err
diff --git a/admin/server/bookmarks_test.go b/admin/server/bookmarks_test.go
new file mode 100644
index 000000000000..55e118b46d54
--- /dev/null
+++ b/admin/server/bookmarks_test.go
@@ -0,0 +1,143 @@
+package server_test
+
+import (
+	"context"
+	"testing"
+
+	"github.com/rilldata/rill/admin/database"
+	"github.com/rilldata/rill/admin/testadmin"
+	adminv1 "github.com/rilldata/rill/proto/gen/rill/admin/v1"
+	"github.com/stretchr/testify/require"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+)
+
+func TestBookmarks(t *testing.T) {
+	ctx := context.Background()
+	fix := testadmin.New(t)
+
+	const exploreKind = "rill.runtime.v1.Explore"
+	const canvasKind = "rill.runtime.v1.Canvas"
+
+	// Create an admin user with an org and a project.
+	_, admin := fix.NewUser(t)
+	org, err := admin.CreateOrganization(ctx, &adminv1.CreateOrganizationRequest{Name: randomName()})
+	require.NoError(t, err)
+	proj, err := admin.CreateProject(ctx, &adminv1.CreateProjectRequest{
+		Org:        org.Organization.Name,
+		Project:    "proj1",
+		ProdSlots:  1,
+		SkipDeploy: true,
+	})
+	require.NoError(t, err)
+	projectID := proj.Project.Id
+
+	// Add a viewer to the project.
+	viewerUser, viewer := fix.NewUser(t)
+	_, err = admin.AddProjectMemberUser(ctx, &adminv1.AddProjectMemberUserRequest{
+		Org:     org.Organization.Name,
+		Project: proj.Project.Name,
+		Email:   viewerUser.Email,
+		Role:    database.ProjectRoleNameViewer,
+	})
+	require.NoError(t, err)
+
+	// A user that is not a member of the project.
+	_, outsider := fix.NewUser(t)
+
+	// Bookmarks across two dashboards: a shared one and a personal one by the admin, and a personal one by the viewer.
+	shared, err := admin.CreateBookmark(ctx, &adminv1.CreateBookmarkRequest{
+		DisplayName:  "Shared explore bookmark",
+		ProjectId:    projectID,
+		ResourceKind: exploreKind,
+		ResourceName: "explore1",
+		Shared:       true,
+		UrlSearch:    "?tr=P7D",
+	})
+	require.NoError(t, err)
+	_, err = admin.CreateBookmark(ctx, &adminv1.CreateBookmarkRequest{
+		DisplayName:  "Admin personal canvas bookmark",
+		ProjectId:    projectID,
+		ResourceKind: canvasKind,
+		ResourceName: "canvas1",
+		UrlSearch:    "?tr=P1D",
+	})
+	require.NoError(t, err)
+	viewerPersonal, err := viewer.CreateBookmark(ctx, &adminv1.CreateBookmarkRequest{
+		DisplayName:  "Viewer personal explore bookmark",
+		ProjectId:    projectID,
+		ResourceKind: exploreKind,
+		ResourceName: "explore1",
+		UrlSearch:    "?tr=P30D",
+	})
+	require.NoError(t, err)
+
+	t.Run("project-wide listing returns own, shared and default bookmarks in a stable order", func(t *testing.T) {
+		res, err := admin.ListBookmarks(ctx, &adminv1.ListBookmarksRequest{ProjectId: projectID})
+		require.NoError(t, err)
+		require.Equal(t, []string{"Admin personal canvas bookmark", "Shared explore bookmark"}, bookmarkNames(res.Bookmarks))
+
+		res, err = viewer.ListBookmarks(ctx, &adminv1.ListBookmarksRequest{ProjectId: projectID})
+		require.NoError(t, err)
+		require.Equal(t, []string{"Shared explore bookmark", "Viewer personal explore bookmark"}, bookmarkNames(res.Bookmarks))
+	})
+
+	t.Run("listing can be filtered by resource", func(t *testing.T) {
+		res, err := admin.ListBookmarks(ctx, &adminv1.ListBookmarksRequest{ProjectId: projectID, ResourceKind: exploreKind, ResourceName: "explore1"})
+		require.NoError(t, err)
+		require.Equal(t, []string{"Shared explore bookmark"}, bookmarkNames(res.Bookmarks))
+
+		// The resource name is matched case-insensitively.
+		res, err = viewer.ListBookmarks(ctx, &adminv1.ListBookmarksRequest{ProjectId: projectID, ResourceKind: exploreKind, ResourceName: "EXPLORE1"})
+		require.NoError(t, err)
+		require.Equal(t, []string{"Shared explore bookmark", "Viewer personal explore bookmark"}, bookmarkNames(res.Bookmarks))
+
+		// Filtering by kind only.
+		res, err = admin.ListBookmarks(ctx, &adminv1.ListBookmarksRequest{ProjectId: projectID, ResourceKind: canvasKind})
+		require.NoError(t, err)
+		require.Equal(t, []string{"Admin personal canvas bookmark"}, bookmarkNames(res.Bookmarks))
+
+		// A resource name without a kind is rejected.
+		_, err = admin.ListBookmarks(ctx, &adminv1.ListBookmarksRequest{ProjectId: projectID, ResourceName: "explore1"})
+		require.Equal(t, codes.InvalidArgument, status.Code(err))
+	})
+
+	t.Run("listing requires read access to the project", func(t *testing.T) {
+		_, err := outsider.ListBookmarks(ctx, &adminv1.ListBookmarksRequest{ProjectId: projectID})
+		require.Equal(t, codes.PermissionDenied, status.Code(err))
+	})
+
+	t.Run("updating a bookmark bumps updated_on", func(t *testing.T) {
+		before, err := viewer.GetBookmark(ctx, &adminv1.GetBookmarkRequest{BookmarkId: viewerPersonal.Bookmark.Id})
+		require.NoError(t, err)
+
+		_, err = viewer.UpdateBookmark(ctx, &adminv1.UpdateBookmarkRequest{
+			BookmarkId:  viewerPersonal.Bookmark.Id,
+			DisplayName: "Viewer personal explore bookmark (renamed)",
+			UrlSearch:   "?tr=P30D",
+		})
+		require.NoError(t, err)
+
+		after, err := viewer.GetBookmark(ctx, &adminv1.GetBookmarkRequest{BookmarkId: viewerPersonal.Bookmark.Id})
+		require.NoError(t, err)
+		require.Equal(t, "Viewer personal explore bookmark (renamed)", after.Bookmark.DisplayName)
+		require.True(t, after.Bookmark.UpdatedOn.AsTime().After(before.Bookmark.UpdatedOn.AsTime()))
+
+		// A viewer cannot update a shared bookmark.
+		_, err = viewer.UpdateBookmark(ctx, &adminv1.UpdateBookmarkRequest{
+			BookmarkId:  shared.Bookmark.Id,
+			DisplayName: "Hijacked",
+			Shared:      true,
+			UrlSearch:   "?tr=P7D",
+		})
+		require.Equal(t, codes.PermissionDenied, status.Code(err))
+	})
+}
+
+func bookmarkNames(bookmarks []*adminv1.Bookmark) []string {
+	names := make([]string, len(bookmarks))
+	for i, b := range bookmarks {
+		names[i] = b.DisplayName
+	}
+	return names
+}
diff --git a/proto/gen/rill/admin/v1/admin.swagger.yaml b/proto/gen/rill/admin/v1/admin.swagger.yaml
index 688313b92244..8c90b02f5897 100644
--- a/proto/gen/rill/admin/v1/admin.swagger.yaml
+++ b/proto/gen/rill/admin/v1/admin.swagger.yaml
@@ -4650,10 +4650,14 @@ paths:
           required: false
           type: string
         - name: resourceKind
+          description: |-
+            Optional filter on the kind of the resource the bookmark is for (e.g. "rill.runtime.v1.Explore").
+            When both resource_kind and resource_name are empty, all bookmarks in the project are returned.
           in: query
           required: false
           type: string
         - name: resourceName
+          description: Optional filter on the name of the resource the bookmark is for. Requires resource_kind to be set.
           in: query
           required: false
           type: string
diff --git a/proto/gen/rill/admin/v1/api.pb.go b/proto/gen/rill/admin/v1/api.pb.go
index f30d1e54f269..5938b2562d38 100644
--- a/proto/gen/rill/admin/v1/api.pb.go
+++ b/proto/gen/rill/admin/v1/api.pb.go
@@ -13020,13 +13020,18 @@ func (*RevokeCurrentAuthTokenResponse) Descriptor() ([]byte, []int) {
 	return file_rill_admin_v1_api_proto_rawDescGZIP(), []int{211}
 }
 
+// ListBookmarksRequest lists the bookmarks in a project that are visible to the caller:
+// the caller's own bookmarks plus shared and default bookmarks.
 type ListBookmarksRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	ProjectId    string `protobuf:"bytes,1,opt,name=project_id,json=projectId,proto3" json:"project_id,omitempty"`
+	ProjectId string `protobuf:"bytes,1,opt,name=project_id,json=projectId,proto3" json:"project_id,omitempty"`
+	// Optional filter on the kind of the resource the bookmark is for (e.g. "rill.runtime.v1.Explore").
+	// When both resource_kind and resource_name are empty, all bookmarks in the project are returned.
 	ResourceKind string `protobuf:"bytes,2,opt,name=resource_kind,json=resourceKind,proto3" json:"resource_kind,omitempty"`
+	// Optional filter on the name of the resource the bookmark is for. Requires resource_kind to be set.
 	ResourceName string `protobuf:"bytes,3,opt,name=resource_name,json=resourceName,proto3" json:"resource_name,omitempty"`
 }
 
diff --git a/proto/gen/rill/admin/v1/openapi.yaml b/proto/gen/rill/admin/v1/openapi.yaml
index 1fbbb11a55b7..1cc64414ef7d 100644
--- a/proto/gen/rill/admin/v1/openapi.yaml
+++ b/proto/gen/rill/admin/v1/openapi.yaml
@@ -8153,11 +8153,15 @@ paths:
                   name: projectId
                   schema:
                     type: string
-                - in: query
+                - description: |-
+                    Optional filter on the kind of the resource the bookmark is for (e.g. "rill.runtime.v1.Explore").
+                    When both resource_kind and resource_name are empty, all bookmarks in the project are returned.
+                  in: query
                   name: resourceKind
                   schema:
                     type: string
-                - in: query
+                - description: Optional filter on the name of the resource the bookmark is for. Requires resource_kind to be set.
+                  in: query
                   name: resourceName
                   schema:
                     type: string
diff --git a/proto/rill/admin/v1/api.proto b/proto/rill/admin/v1/api.proto
index ee056e2c3b03..076b53c0cf30 100644
--- a/proto/rill/admin/v1/api.proto
+++ b/proto/rill/admin/v1/api.proto
@@ -2650,9 +2650,14 @@ message RevokeCurrentAuthTokenRequest {}
 message RevokeCurrentAuthTokenResponse {
 }
 
+// ListBookmarksRequest lists the bookmarks in a project that are visible to the caller:
+// the caller's own bookmarks plus shared and default bookmarks.
 message ListBookmarksRequest {
   string project_id = 1;
+  // Optional filter on the kind of the resource the bookmark is for (e.g. "rill.runtime.v1.Explore").
+  // When both resource_kind and resource_name are empty, all bookmarks in the project are returned.
   string resource_kind = 2;
+  // Optional filter on the name of the resource the bookmark is for. Requires resource_kind to be set.
   string resource_name = 3;
 }
 
diff --git a/web-admin/src/client/gen/index.schemas.ts b/web-admin/src/client/gen/index.schemas.ts
index 4084393a1cf0..71c8b0bd7538 100644
--- a/web-admin/src/client/gen/index.schemas.ts
+++ b/web-admin/src/client/gen/index.schemas.ts
@@ -2534,7 +2534,14 @@ This is only allowed for superusers. */
 
 export type AdminServiceListBookmarksParams = {
   projectId?: string;
+  /**
+ * Optional filter on the kind of the resource the bookmark is for (e.g. "rill.runtime.v1.Explore").
+When both resource_kind and resource_name are empty, all bookmarks in the project are returned.
+ */
   resourceKind?: string;
+  /**
+   * Optional filter on the name of the resource the bookmark is for. Requires resource_kind to be set.
+   */
   resourceName?: string;
 };
 
diff --git a/web-admin/src/features/bookmarks/BookmarkMetadataDialog.svelte b/web-admin/src/features/bookmarks/BookmarkMetadataDialog.svelte
new file mode 100644
index 000000000000..15e20757045b
--- /dev/null
+++ b/web-admin/src/features/bookmarks/BookmarkMetadataDialog.svelte
@@ -0,0 +1,145 @@
+<script lang="ts">
+  import { m } from "@rilldata/web-common/lib/i18n/gen/messages";
+  import {
+    createAdminServiceUpdateBookmark,
+    type V1Bookmark,
+  } from "@rilldata/web-admin/client";
+  import { getRpcErrorMessage } from "@rilldata/web-admin/components/errors/error-utils.ts";
+  import { invalidateBookmarkQueries } from "@rilldata/web-admin/features/bookmarks/selectors.ts";
+  import ProjectAccessControls from "@rilldata/web-admin/features/projects/ProjectAccessControls.svelte";
+  import { Button } from "@rilldata/web-common/components/button";
+  import * as Dialog from "@rilldata/web-common/components/dialog";
+  import Input from "@rilldata/web-common/components/forms/Input.svelte";
+  import Select from "@rilldata/web-common/components/forms/Select.svelte";
+  import { eventBus } from "@rilldata/web-common/lib/event-bus/event-bus.ts";
+  import { defaults, superForm } from "sveltekit-superforms";
+  import { yup } from "sveltekit-superforms/adapters";
+  import { object, string } from "yup";
+
+  // Edits a bookmark's name, description and category without touching its saved dashboard state.
+  // Changing the saved state requires the dashboard itself (see BookmarksFormDialog).
+  export let organization: string;
+  export let project: string;
+  export let bookmark: V1Bookmark;
+  // Link to the bookmark on its dashboard, where its filters can be changed.
+  export let href: string | undefined = undefined;
+  export let onClose = () => {};
+
+  const bookmarkUpdater = createAdminServiceUpdateBookmark();
+
+  const initialValues = {
+    displayName: bookmark.displayName ?? "",
+    description: bookmark.description ?? "",
+    shared: bookmark.shared ? "true" : "false",
+  };
+
+  const schema = yup(
+    object({
+      displayName: string().required("Required"),
+      description: string(),
+      shared: string(),
+    }),
+  );
+
+  const formId = "edit-bookmark-metadata-dialog";
+
+  const { form, errors, submit, enhance } = superForm(
+    defaults(initialValues, schema),
+    {
+      SPA: true,
+      validators: schema,
+      async onUpdate({ form }) {
+        if (!form.valid) return;
+        const values = form.data;
+
+        await $bookmarkUpdater.mutateAsync({
+          data: {
+            bookmarkId: bookmark.id,
+            displayName: values.displayName,
+            description: values.description,
+            // Home bookmarks are always shared.
+            shared: bookmark.default || values.shared === "true",
+            urlSearch: bookmark.urlSearch ?? "",
+          },
+        });
+        onClose();
+
+        await invalidateBookmarkQueries();
+        eventBus.emit("notification", {
+          message: m.bookmark_updated(),
+        });
+      },
+    },
+  );
+
+  $: error = getRpcErrorMessage($bookmarkUpdater.error ?? undefined);
+</script>
+
+<Dialog.Root
+  open
+  onOpenChange={(o) => {
+    if (!o) onClose();
+  }}
+>
+  <Dialog.Content>
+    <Dialog.Header>
+      <Dialog.Title>{m.bookmark_edit()}</Dialog.Title>
+    </Dialog.Header>
+
+    <form
+      class="flex flex-col gap-4"
+      id={formId}
+      use:enhance
+      onsubmit={(e) => {
+        e.preventDefault();
+        submit(e);
+      }}
+    >
+      <Input
+        bind:value={$form["displayName"]}
+        errors={$errors["displayName"]}
+        id="displayName"
+        label={m.bookmark_label()}
+      />
+      <Input
+        bind:value={$form["description"]}
+        errors={$errors["description"]}
+        id="description"
+        label={m.bookmark_description()}
+        optional
+      />
+      {#if !bookmark.default}
+        <ProjectAccessControls {organization} {project}>
+          <Select
+            bind:value={$form["shared"]}
+            id="shared"
+            label={m.bookmark_category()}
+            options={[
+              { value: "false", label: m.bookmark_your_bookmarks() },
+              { value: "true", label: m.bookmark_managed_bookmarks() },
+            ]}
+            slot="manage-project"
+            tooltip={m.bookmark_category_tooltip()}
+          />
+        </ProjectAccessControls>
+      {/if}
+      {#if href}
+        <div class="text-sm text-fg-secondary">
+          {m.bookmark_filters()}:
+          <a {href}>{m.bookmark_edit_filters_on_dashboard()}</a>
+        </div>
+      {/if}
+      {#if error}
+        <div class="text-red-500 text-sm py-px">
+          {error}
+        </div>
+      {/if}
+    </form>
+
+    <div class="flex flex-row mt-4 gap-2">
+      <div class="grow"></div>
+      <Button onClick={onClose} type="secondary">{m.common_cancel()}</Button>
+      <Button onClick={submit} type="primary">{m.bookmark_save()}</Button>
+    </div>
+  </Dialog.Content>
+</Dialog.Root>
diff --git a/web-admin/src/features/bookmarks/Bookmarks.svelte b/web-admin/src/features/bookmarks/Bookmarks.svelte
index 090e17a01149..0329bc6ec58c 100644
--- a/web-admin/src/features/bookmarks/Bookmarks.svelte
+++ b/web-admin/src/features/bookmarks/Bookmarks.svelte
@@ -5,12 +5,14 @@
     createAdminServiceCreateBookmark,
     createAdminServiceRemoveBookmark,
     createAdminServiceUpdateBookmark,
-    getAdminServiceListBookmarksQueryKey,
     type V1Bookmark,
   } from "@rilldata/web-admin/client";
   import BookmarksMenuItem from "@rilldata/web-admin/features/bookmarks/BookmarksMenuItem.svelte";
   import BookmarksFormDialog from "@rilldata/web-admin/features/bookmarks/BookmarksFormDialog.svelte";
-  import { isHomeBookmark } from "@rilldata/web-admin/features/bookmarks/selectors.ts";
+  import {
+    invalidateBookmarkQueries,
+    isHomeBookmark,
+  } from "@rilldata/web-admin/features/bookmarks/selectors.ts";
   import {
     type BookmarkEntry,
     type Bookmarks,
@@ -18,6 +20,7 @@
     searchBookmarks,
   } from "@rilldata/web-admin/features/bookmarks/utils.ts";
   import HomeBookmarkButton from "@rilldata/web-admin/features/bookmarks/HomeBookmarkButton.svelte";
+  import { RecentlyUsedBookmarks } from "@rilldata/web-admin/features/bookmarks/recently-used-bookmarks.ts";
   import {
     getProjectIdQueryOptions,
     getProjectPermissions,
@@ -35,7 +38,7 @@
   import { Search } from "@rilldata/web-common/components/search";
   import { ResourceKind } from "@rilldata/web-common/features/entity-management/resource-selectors.ts";
   import { eventBus } from "@rilldata/web-common/lib/event-bus/event-bus.ts";
-  import { createQuery, useQueryClient } from "@tanstack/svelte-query";
+  import { createQuery } from "@tanstack/svelte-query";
   import { BookmarkIcon, BookmarkPlusIcon } from "lucide-svelte";
   import { writable } from "svelte/store";
 
@@ -63,6 +66,11 @@
   let showDialog = false;
   let bookmark: BookmarkEntry | null = null;
 
+  $: recentlyUsedBookmarks = new RecentlyUsedBookmarks(organization, project);
+  function recordUsage(bookmark: BookmarkEntry) {
+    recentlyUsedBookmarks.update(bookmark.resource.id);
+  }
+
   const orgAndProjectNameStore = writable({ organization: "", project: "" });
   $: orgAndProjectNameStore.set({ organization, project });
 
@@ -76,7 +84,6 @@
 
   $: curUrlParams = $page.url.searchParams;
 
-  const queryClient = useQueryClient();
   const bookmarkCreator = createAdminServiceCreateBookmark();
   const bookmarkUpdater = createAdminServiceUpdateBookmark();
   const bookmarkDeleter = createAdminServiceRemoveBookmark();
@@ -117,13 +124,7 @@
     eventBus.emit("notification", {
       message: m.bookmark_home_created(),
     });
-    return queryClient.refetchQueries({
-      queryKey: getAdminServiceListBookmarksQueryKey({
-        projectId,
-        resourceKind,
-        resourceName,
-      }),
-    });
+    return invalidateBookmarkQueries();
   }
 
   function onEdit(editingBookmark: BookmarkEntry) {
@@ -141,13 +142,7 @@
         name: bookmark.resource.displayName ?? "",
       }),
     });
-    return queryClient.refetchQueries({
-      queryKey: getAdminServiceListBookmarksQueryKey({
-        projectId,
-        resourceKind,
-        resourceName,
-      }),
-    });
+    return invalidateBookmarkQueries();
   }
 
   let open = false;
@@ -165,6 +160,7 @@
   {defaultHomeBookmarkUrl}
   onCreate={createHomeBookmark}
   onDelete={deleteBookmark}
+  onOpen={recordUsage}
   {manageProject}
 />
 
@@ -223,6 +219,7 @@
                   {bookmark}
                   {onEdit}
                   onDelete={deleteBookmark}
+                  onClick={() => recordUsage(bookmark)}
                 />
               {/key}
             {/each}
@@ -251,6 +248,7 @@
                   {bookmark}
                   {onEdit}
                   onDelete={deleteBookmark}
+                  onClick={() => recordUsage(bookmark)}
                   readOnly={!manageProject}
                 />
               {/key}
diff --git a/web-admin/src/features/bookmarks/BookmarksFormDialog.svelte b/web-admin/src/features/bookmarks/BookmarksFormDialog.svelte
index 69a689de7a5c..1c819491d9f0 100644
--- a/web-admin/src/features/bookmarks/BookmarksFormDialog.svelte
+++ b/web-admin/src/features/bookmarks/BookmarksFormDialog.svelte
@@ -4,8 +4,8 @@
   import {
     createAdminServiceCreateBookmark,
     createAdminServiceUpdateBookmark,
-    getAdminServiceListBookmarksQueryKey,
   } from "@rilldata/web-admin/client";
+  import { invalidateBookmarkQueries } from "@rilldata/web-admin/features/bookmarks/selectors.ts";
   import {
     type BookmarkEntry,
     formatTimeRange,
@@ -27,7 +27,6 @@
   import { ExploreStateURLParams } from "@rilldata/web-common/features/dashboards/url-state/url-params";
   import { ResourceKind } from "@rilldata/web-common/features/entity-management/resource-selectors.ts";
   import { eventBus } from "@rilldata/web-common/lib/event-bus/event-bus.ts";
-  import { queryClient } from "@rilldata/web-common/lib/svelte-query/globalQueryClient.ts";
   import {
     V1TimeGrain,
     type V1TimeRange,
@@ -225,13 +224,7 @@
         }
         onClose();
 
-        await queryClient.refetchQueries({
-          queryKey: getAdminServiceListBookmarksQueryKey({
-            projectId,
-            resourceKind,
-            resourceName,
-          }),
-        });
+        await invalidateBookmarkQueries();
         eventBus.emit("notification", {
           message: bookmark ? m.bookmark_updated() : m.bookmark_created(),
         });
diff --git a/web-admin/src/features/bookmarks/HomeBookmarkButton.svelte b/web-admin/src/features/bookmarks/HomeBookmarkButton.svelte
index 12981db62600..233d03bfca32 100644
--- a/web-admin/src/features/bookmarks/HomeBookmarkButton.svelte
+++ b/web-admin/src/features/bookmarks/HomeBookmarkButton.svelte
@@ -25,6 +25,8 @@
   export let manageProject: boolean;
   export let onCreate: () => void;
   export let onDelete: (bookmark: BookmarkEntry) => Promise<void>;
+  // Called when the user navigates to the home bookmark, so usage can be tracked.
+  export let onOpen: (bookmark: BookmarkEntry) => void = () => {};
 
   $: ({ name: resourceName, kind: resourceKind } = resource);
 
@@ -68,6 +70,7 @@
         <BookmarksMenuItem
           bookmark={homeBookmark}
           {onDelete}
+          onClick={() => homeBookmark && onOpen(homeBookmark)}
           readOnly={!manageProject}
           showDeleteTooltip
         />
@@ -116,7 +119,10 @@
           compact
           preload={false}
           href={fullHomeBookmarkUrl}
-          onClick={goToDashboardHome}
+          onClick={() => {
+            if (homeBookmark) onOpen(homeBookmark);
+            goToDashboardHome();
+          }}
           class="border border-primary-300"
           label={m.bookmark_go_to_home_label()}
           active={isHomeBookmarkActive}
diff --git a/web-admin/src/features/bookmarks/listing/BookmarksTable.svelte b/web-admin/src/features/bookmarks/listing/BookmarksTable.svelte
new file mode 100644
index 000000000000..94733ada45c9
--- /dev/null
+++ b/web-admin/src/features/bookmarks/listing/BookmarksTable.svelte
@@ -0,0 +1,272 @@
+<script lang="ts">
+  import { page } from "$app/state";
+  import {
+    createAdminServiceGetCurrentUser,
+    createAdminServiceRemoveBookmark,
+    type RpcStatus,
+  } from "@rilldata/web-admin/client";
+  import { getRpcErrorMessage } from "@rilldata/web-admin/components/errors/error-utils.ts";
+  import BookmarkMetadataDialog from "@rilldata/web-admin/features/bookmarks/BookmarkMetadataDialog.svelte";
+  import {
+    type BookmarkListRow,
+    BookmarkTableSortOptions,
+    buildBookmarkRows,
+    filterBookmarkRows,
+  } from "@rilldata/web-admin/features/bookmarks/listing/bookmark-listing-utils.ts";
+  import BookmarksTableCompositeCell from "@rilldata/web-admin/features/bookmarks/listing/BookmarksTableCompositeCell.svelte";
+  import { RecentlyUsedBookmarks } from "@rilldata/web-admin/features/bookmarks/recently-used-bookmarks.ts";
+  import {
+    getProjectBookmarksQueryOptions,
+    invalidateBookmarkQueries,
+  } from "@rilldata/web-admin/features/bookmarks/selectors.ts";
+  import { useDashboards } from "@rilldata/web-admin/features/dashboards/listing/selectors.ts";
+  import { getProjectPermissions } from "@rilldata/web-admin/features/projects/selectors.ts";
+  import ResourceList from "@rilldata/web-admin/features/resources/ResourceList.svelte";
+  import ResourceListEmptyState from "@rilldata/web-admin/features/resources/ResourceListEmptyState.svelte";
+  import { AlertDialogConfirmation } from "@rilldata/web-common/components/alert-dialog";
+  import BookmarkOutline from "@rilldata/web-common/components/icons/BookmarkOutline.svelte";
+  import { TableToolbar } from "@rilldata/web-common/components/table-toolbar";
+  import DelayedSpinner from "@rilldata/web-common/features/entity-management/DelayedSpinner.svelte";
+  import ResourceError from "@rilldata/web-common/features/resources/ResourceError.svelte";
+  import { eventBus } from "@rilldata/web-common/lib/event-bus/event-bus.ts";
+  import { m } from "@rilldata/web-common/lib/i18n/gen/messages";
+  import { type RuneStore } from "@rilldata/web-common/lib/store-utils/types.svelte.ts";
+  import { DebouncedRuneStore } from "@rilldata/web-common/lib/store-utils/types.svelte.ts";
+  import { UrlParamsState } from "@rilldata/web-common/lib/store-utils/url-params-state.svelte.ts";
+  import { useRuntimeClient } from "@rilldata/web-common/runtime-client/v2";
+  import { createQuery } from "@tanstack/svelte-query";
+  import { renderComponent } from "tanstack-table-8-svelte-5";
+  import { writable } from "svelte/store";
+
+  let {
+    isPreview = false,
+    previewLimit = undefined,
+    sortStore: sortStoreProp = undefined,
+  }: {
+    isPreview?: boolean;
+    previewLimit?: number;
+    // Lets a parent share the sort state, e.g. the project home page renders the sort dropdown in its heading.
+    sortStore?: RuneStore<string>;
+  } = $props();
+
+  const defaultSortStore = UrlParamsState.createStringParam(
+    "sort",
+    BookmarkTableSortOptions[0].value,
+  );
+  let sortStore = $derived(sortStoreProp ?? defaultSortStore);
+  let sortingOption = $derived(
+    BookmarkTableSortOptions.find(
+      (option) => option.value === sortStore.value,
+    ) ?? BookmarkTableSortOptions[0],
+  );
+  // Secondary sort by name keeps rows with the same primary value in a stable order.
+  let sorting = $derived(
+    sortingOption.sort.id === "name"
+      ? [sortingOption.sort]
+      : [sortingOption.sort, { id: "name", desc: false }],
+  );
+
+  const searchTextStore = new DebouncedRuneStore(
+    UrlParamsState.createStringParam("q"),
+    500,
+  );
+
+  const runtimeClient = useRuntimeClient();
+  let { organization, project } = $derived(page.params);
+
+  const orgAndProjectNameStore = writable({
+    organization: page.params.organization,
+    project: page.params.project,
+  });
+  $effect(() => {
+    orgAndProjectNameStore.set({ organization, project });
+  });
+
+  const user = createAdminServiceGetCurrentUser();
+  const bookmarksQuery = createQuery(
+    getProjectBookmarksQueryOptions(orgAndProjectNameStore),
+  );
+  const dashboardsQuery = useDashboards(runtimeClient);
+  let permissionsQuery = $derived(getProjectPermissions(organization, project));
+
+  let { data: userData, isPending: isUserPending } = $derived($user);
+  let {
+    data: bookmarksData,
+    isPending: isBookmarksPending,
+    isError,
+    error,
+  } = $derived($bookmarksQuery);
+  let { data: dashboardsData } = $derived($dashboardsQuery);
+  let { data: permissions } = $derived($permissionsQuery);
+  let recentlyUsedBookmarks = $derived(
+    new RecentlyUsedBookmarks(organization, project),
+  );
+
+  let hasUser = $derived(!!userData?.user);
+  // Anonymous viewers have no bookmarks, so only wait on the bookmarks query when there is a user.
+  let isLoading = $derived(isUserPending || (hasUser && isBookmarksPending));
+
+  let rows = $derived(
+    buildBookmarkRows({
+      bookmarks: bookmarksData?.bookmarks ?? [],
+      dashboards: dashboardsData ?? [],
+      organization,
+      project,
+      currentUserId: userData?.user?.id,
+      manageBookmarks: !!permissions?.manageBookmarks,
+      recentlyUsed: recentlyUsedBookmarks.recentlyUsed.value,
+    }),
+  );
+  let filteredRows = $derived(filterBookmarkRows(rows, searchTextStore.value));
+  let hasMoreBookmarks = $derived(
+    isPreview &&
+      previewLimit !== undefined &&
+      filteredRows.length > previewLimit,
+  );
+
+  let editing = $state<BookmarkListRow | null>(null);
+  let deleting = $state<BookmarkListRow | null>(null);
+
+  const bookmarkDeleter = createAdminServiceRemoveBookmark();
+
+  async function confirmDelete() {
+    if (!deleting) return;
+    const name = deleting.bookmark.displayName ?? "";
+    try {
+      await $bookmarkDeleter.mutateAsync({
+        bookmarkId: deleting.bookmark.id ?? "",
+      });
+    } catch (e) {
+      eventBus.emit("notification", {
+        message: getRpcErrorMessage(e as RpcStatus) ?? String(e),
+        type: "error",
+      });
+      return;
+    }
+    deleting = null;
+    eventBus.emit("notification", {
+      message: m.bookmark_deleted({ name }),
+    });
+    await invalidateBookmarkQueries();
+  }
+
+  const columns = [
+    {
+      id: "composite",
+      cell: ({ row }) =>
+        renderComponent(BookmarksTableCompositeCell, {
+          row: row.original as BookmarkListRow,
+          onOpen: (row: BookmarkListRow) =>
+            recentlyUsedBookmarks.update(row.bookmark.id),
+          onEdit: (row: BookmarkListRow) => (editing = row),
+          onDelete: (row: BookmarkListRow) => (deleting = row),
+        }),
+    },
+    {
+      id: "name",
+      accessorFn: (row: BookmarkListRow) =>
+        row.bookmark.displayName?.toLowerCase() ?? "",
+    },
+    {
+      id: "updatedOn",
+      accessorFn: (row: BookmarkListRow) =>
+        row.bookmark.updatedOn ? new Date(row.bookmark.updatedOn).getTime() : 0,
+    },
+    {
+      id: "dashboard",
+      accessorFn: (row: BookmarkListRow) => row.dashboardTitle.toLowerCase(),
+    },
+    {
+      id: "lastUsed",
+      accessorFn: (row: BookmarkListRow) => row.lastUsed,
+    },
+  ];
+
+  const columnVisibility = {
+    name: false,
+    updatedOn: false,
+    dashboard: false,
+    lastUsed: false,
+  };
+</script>
+
+{#if isLoading}
+  <div class="m-auto mt-20">
+    <DelayedSpinner isLoading={true} size="24px" />
+  </div>
+{:else if isError}
+  <ResourceError kind="bookmark" {error} />
+{:else}
+  <div class="flex flex-col w-full gap-y-3">
+    {#if !isPreview}
+      <TableToolbar
+        {searchTextStore}
+        {sortStore}
+        sortOptions={BookmarkTableSortOptions}
+      />
+    {/if}
+
+    <div class="flex flex-col flex-grow min-w-0">
+      <ResourceList
+        kind="bookmark"
+        data={filteredRows}
+        {columns}
+        {columnVisibility}
+        {sorting}
+        toolbar={false}
+        maxRows={previewLimit}
+        getRowId={(row) => (row as BookmarkListRow).bookmark.id ?? ""}
+      >
+        <svelte:fragment slot="empty">
+          {#if searchTextStore.value}
+            <ResourceListEmptyState
+              icon={BookmarkOutline}
+              message={m.bookmark_list_no_match()}
+            />
+          {:else}
+            <ResourceListEmptyState
+              icon={BookmarkOutline}
+              message={m.bookmark_list_empty()}
+              action={m.bookmark_list_empty_action()}
+            />
+          {/if}
+        </svelte:fragment>
+      </ResourceList>
+
+      {#if hasMoreBookmarks}
+        <div class="pl-4 py-1">
+          <a
+            href={`/${organization}/${project}/-/bookmarks`}
+            class="text-sm font-medium text-primary-600 hover:text-primary-700 transition-colors inline-block"
+          >
+            {m.bookmark_list_see_all()} →
+          </a>
+        </div>
+      {/if}
+    </div>
+  </div>
+{/if}
+
+{#if editing}
+  <BookmarkMetadataDialog
+    {organization}
+    {project}
+    bookmark={editing.bookmark}
+    href={editing.href}
+    onClose={() => (editing = null)}
+  />
+{/if}
+
+<AlertDialogConfirmation
+  open={!!deleting}
+  onOpenChange={(open) => {
+    if (!open) deleting = null;
+  }}
+  title={m.bookmark_delete_confirm_title()}
+  description={m.bookmark_delete_confirm_description({
+    name: deleting?.bookmark.displayName ?? "",
+  })}
+  confirmLabel={m.common_delete()}
+  confirmType="destructive"
+  onConfirm={confirmDelete}
+/>
diff --git a/web-admin/src/features/bookmarks/listing/BookmarksTableCompositeCell.svelte b/web-admin/src/features/bookmarks/listing/BookmarksTableCompositeCell.svelte
new file mode 100644
index 000000000000..1c026a9eabf6
--- /dev/null
+++ b/web-admin/src/features/bookmarks/listing/BookmarksTableCompositeCell.svelte
@@ -0,0 +1,150 @@
+<script lang="ts">
+  import type { BookmarkListRow } from "@rilldata/web-admin/features/bookmarks/listing/bookmark-listing-utils.ts";
+  import Button from "@rilldata/web-common/components/button/Button.svelte";
+  import BookmarkOutline from "@rilldata/web-common/components/icons/BookmarkOutline.svelte";
+  import FilterOutline from "@rilldata/web-common/components/icons/FilterOutline.svelte";
+  import HomeBookmark from "@rilldata/web-common/components/icons/HomeBookmark.svelte";
+  import Trash from "@rilldata/web-common/components/icons/Trash.svelte";
+  import Tag from "@rilldata/web-common/components/tag/Tag.svelte";
+  import * as Tooltip from "@rilldata/web-common/components/tooltip-v2";
+  import ResourceTypeBadge from "@rilldata/web-common/features/entity-management/ResourceTypeBadge.svelte";
+  import { m } from "@rilldata/web-common/lib/i18n/gen/messages";
+  import { timeAgo } from "@rilldata/web-common/lib/time/relative-time";
+  import { Pencil } from "lucide-svelte";
+
+  let {
+    row,
+    onOpen,
+    onEdit,
+    onDelete,
+  }: {
+    row: BookmarkListRow;
+    onOpen: (row: BookmarkListRow) => void;
+    onEdit: (row: BookmarkListRow) => void;
+    onDelete: (row: BookmarkListRow) => void;
+  } = $props();
+
+  let Icon = $derived(
+    row.category === "home"
+      ? HomeBookmark
+      : row.filtersOnly
+        ? FilterOutline
+        : BookmarkOutline,
+  );
+  let displayName = $derived(row.bookmark.displayName ?? "");
+  let updatedOn = $derived(
+    row.bookmark.updatedOn ? new Date(row.bookmark.updatedOn) : null,
+  );
+  let lastUsed = $derived(row.lastUsed ? new Date(row.lastUsed) : null);
+
+  let hovered = $state(false);
+</script>
+
+<div
+  class="flex flex-row items-center gap-x-2 group px-4 w-full h-full"
+  onmouseenter={() => (hovered = true)}
+  onmouseleave={() => (hovered = false)}
+  role="row"
+  tabindex="-1"
+>
+  <a
+    class="flex flex-row items-center gap-x-3 min-w-0 grow h-full py-2.5"
+    href={row.href}
+    aria-label={m.bookmark_entry_aria_label({ name: displayName })}
+    onclick={() => onOpen(row)}
+  >
+    <Icon size="16px" className="shrink-0 text-fg-secondary" />
+    <div class="flex flex-col gap-y-1 min-w-0 grow">
+      <div class="flex gap-x-2 items-center min-h-[20px]">
+        <span
+          class="text-fg-secondary text-sm font-semibold group-hover:text-accent-primary-action truncate"
+        >
+          {displayName}
+        </span>
+        {#if row.category === "home"}
+          <Tag color="blue">{m.bookmark_tag_home()}</Tag>
+        {:else if row.category === "managed"}
+          <Tag color="gray">{m.bookmark_tag_managed()}</Tag>
+        {/if}
+        {#if row.isLegacy}
+          <Tooltip.Root>
+            <Tooltip.Trigger>
+              {#snippet child({ props })}
+                <span {...props}>
+                  <Tag color="amber">{m.bookmark_tag_legacy()}</Tag>
+                </span>
+              {/snippet}
+            </Tooltip.Trigger>
+            <Tooltip.Content side="bottom">
+              {m.bookmark_legacy_tooltip()}
+            </Tooltip.Content>
+          </Tooltip.Root>
+        {/if}
+      </div>
+      <div
+        class="flex gap-x-1 items-center text-fg-tertiary text-xs font-normal min-h-[16px] overflow-hidden"
+      >
+        {#if row.dashboardKind}
+          <ResourceTypeBadge kind={row.dashboardKind} />
+        {/if}
+        <span class="shrink-0 truncate max-w-64">{row.dashboardTitle}</span>
+        {#if updatedOn}
+          <span class="shrink-0">•</span>
+          <Tooltip.Root>
+            <Tooltip.Trigger>
+              {#snippet child({ props })}
+                <span {...props} class="shrink-0">
+                  {m.bookmark_updated_ago({ time: timeAgo(updatedOn) })}
+                </span>
+              {/snippet}
+            </Tooltip.Trigger>
+            <Tooltip.Content side="bottom">
+              {updatedOn.toLocaleString()}
+            </Tooltip.Content>
+          </Tooltip.Root>
+        {/if}
+        {#if lastUsed}
+          <span class="shrink-0">•</span>
+          <Tooltip.Root>
+            <Tooltip.Trigger>
+              {#snippet child({ props })}
+                <span {...props} class="shrink-0">
+                  {m.bookmark_last_used_ago({ time: timeAgo(lastUsed) })}
+                </span>
+              {/snippet}
+            </Tooltip.Trigger>
+            <Tooltip.Content side="bottom">
+              {lastUsed.toLocaleString()}
+            </Tooltip.Content>
+          </Tooltip.Root>
+        {/if}
+        {#if row.bookmark.description}
+          <span class="shrink-0">•</span>
+          <span class="truncate">{row.bookmark.description}</span>
+        {/if}
+      </div>
+    </div>
+  </a>
+  {#if row.canManage}
+    <div class="flex flex-row justify-end items-center gap-x-1 w-16 shrink-0">
+      {#if hovered}
+        <Button
+          square
+          type="tertiary"
+          label={m.bookmark_edit()}
+          onClick={() => onEdit(row)}
+        >
+          <Pencil size="16px" />
+        </Button>
+        <Button
+          square
+          type="tertiary"
+          label={m.bookmark_delete_bookmark()}
+          onClick={() => onDelete(row)}
+        >
+          <Trash size="16px" />
+        </Button>
+      {/if}
+    </div>
+  {/if}
+</div>
diff --git a/web-admin/src/features/bookmarks/listing/bookmark-listing-utils.spec.ts b/web-admin/src/features/bookmarks/listing/bookmark-listing-utils.spec.ts
new file mode 100644
index 000000000000..516794b124d8
--- /dev/null
+++ b/web-admin/src/features/bookmarks/listing/bookmark-listing-utils.spec.ts
@@ -0,0 +1,189 @@
+import type { V1Bookmark } from "@rilldata/web-admin/client";
+import {
+  buildBookmarkRows,
+  filterBookmarkRows,
+} from "@rilldata/web-admin/features/bookmarks/listing/bookmark-listing-utils.ts";
+import { ResourceKind } from "@rilldata/web-common/features/entity-management/resource-selectors";
+import type { V1Resource } from "@rilldata/web-common/runtime-client";
+import { describe, expect, it } from "vitest";
+
+const dashboards: V1Resource[] = [
+  {
+    meta: { name: { kind: ResourceKind.Explore, name: "Auction_Explore" } },
+    explore: { spec: { displayName: "Programmatic Ads Auction" } },
+  },
+  {
+    meta: { name: { kind: ResourceKind.Canvas, name: "overview_canvas" } },
+    canvas: { spec: { displayName: "" } },
+  },
+];
+
+function bookmark(overrides: Partial<V1Bookmark>): V1Bookmark {
+  return {
+    id: "b1",
+    displayName: "My bookmark",
+    description: "",
+    urlSearch: "?view=tdd&tr=P7D&f=domain IN ('a')",
+    resourceKind: ResourceKind.Explore,
+    resourceName: "auction_explore",
+    userId: "u1",
+    default: false,
+    shared: false,
+    ...overrides,
+  };
+}
+
+function rowsFor(
+  bookmarks: V1Bookmark[],
+  manageBookmarks = false,
+  recentlyUsed: Record<string, number> = {},
+) {
+  return buildBookmarkRows({
+    bookmarks,
+    dashboards,
+    organization: "org",
+    project: "proj",
+    currentUserId: "u1",
+    manageBookmarks,
+    recentlyUsed,
+  });
+}
+
+describe("buildBookmarkRows", () => {
+  it("links explore bookmarks to the explore with the saved params", () => {
+    const [row] = rowsFor([bookmark({})]);
+    expect(row.href).toBe(
+      "/org/proj/explore/auction_explore?view=tdd&tr=P7D&f=domain IN ('a')",
+    );
+    expect(row.dashboardKind).toBe(ResourceKind.Explore);
+    expect(row.dashboardTitle).toBe("Programmatic Ads Auction");
+    expect(row.category).toBe("personal");
+    expect(row.filtersOnly).toBe(false);
+    expect(row.isLegacy).toBe(false);
+  });
+
+  it("links canvas bookmarks to the canvas and falls back to the resource name as title", () => {
+    const [row] = rowsFor([
+      bookmark({
+        resourceKind: ResourceKind.Canvas,
+        resourceName: "overview_canvas",
+        urlSearch: "tr=P1D",
+      }),
+    ]);
+    expect(row.href).toBe("/org/proj/canvas/overview_canvas?tr=P1D");
+    expect(row.dashboardKind).toBe(ResourceKind.Canvas);
+    expect(row.dashboardTitle).toBe("overview_canvas");
+  });
+
+  it("uses the resource name when the dashboard is not in the project", () => {
+    const [row] = rowsFor([bookmark({ resourceName: "deleted_explore" })]);
+    expect(row.dashboardTitle).toBe("deleted_explore");
+    expect(row.href).toBe(
+      "/org/proj/explore/deleted_explore?view=tdd&tr=P7D&f=domain IN ('a')",
+    );
+  });
+
+  it("does not link bookmarks for unknown resource kinds", () => {
+    const [row] = rowsFor([
+      bookmark({ resourceKind: "rill.runtime.v1.Report" }),
+    ]);
+    expect(row.href).toBeUndefined();
+    expect(row.dashboardKind).toBeUndefined();
+  });
+
+  it("opens legacy bookmarks on the dashboard without params", () => {
+    const [row] = rowsFor([bookmark({ urlSearch: "", data: "AAAA" })]);
+    expect(row.isLegacy).toBe(true);
+    expect(row.filtersOnly).toBe(false);
+    expect(row.href).toBe("/org/proj/explore/auction_explore");
+  });
+
+  it("detects filters-only bookmarks", () => {
+    const [row] = rowsFor([bookmark({ urlSearch: "?tr=P7D&grain=day" })]);
+    expect(row.filtersOnly).toBe(true);
+  });
+
+  it("categorises home, managed and personal bookmarks", () => {
+    const rows = rowsFor([
+      bookmark({ id: "home", default: true, shared: true }),
+      bookmark({ id: "managed", shared: true }),
+      bookmark({ id: "personal" }),
+    ]);
+    expect(rows.map((r) => r.category)).toEqual([
+      "home",
+      "managed",
+      "personal",
+    ]);
+  });
+
+  it("lets owners manage personal bookmarks and admins manage shared ones", () => {
+    const viewerRows = rowsFor([
+      bookmark({ id: "mine" }),
+      bookmark({ id: "theirs", userId: "u2" }),
+      bookmark({ id: "managed", shared: true, userId: "u2" }),
+      bookmark({ id: "home", default: true, shared: true, userId: "u2" }),
+    ]);
+    expect(viewerRows.map((r) => r.canManage)).toEqual([
+      true,
+      false,
+      false,
+      false,
+    ]);
+
+    const adminRows = rowsFor(
+      [
+        bookmark({ id: "managed", shared: true, userId: "u2" }),
+        bookmark({ id: "home", default: true, shared: true, userId: "u2" }),
+      ],
+      true,
+    );
+    expect(adminRows.map((r) => r.canManage)).toEqual([true, true]);
+  });
+});
+
+describe("buildBookmarkRows last used", () => {
+  it("reads the last used time by bookmark id and defaults to zero", () => {
+    const rows = rowsFor(
+      [bookmark({ id: "opened" }), bookmark({ id: "never" })],
+      false,
+      { opened: 1700000000000 },
+    );
+    expect(rows.map((r) => r.lastUsed)).toEqual([1700000000000, 0]);
+  });
+});
+
+describe("filterBookmarkRows", () => {
+  const rows = rowsFor([
+    bookmark({ id: "1", displayName: "Weekly review", description: "" }),
+    bookmark({
+      id: "2",
+      displayName: "Top domains",
+      description: "Daily check of top publishers",
+    }),
+    bookmark({
+      id: "3",
+      displayName: "Canvas view",
+      resourceKind: ResourceKind.Canvas,
+      resourceName: "overview_canvas",
+    }),
+  ]);
+
+  it("returns all rows for an empty search", () => {
+    expect(filterBookmarkRows(rows, "  ")).toHaveLength(3);
+  });
+
+  it("matches name, description and dashboard case-insensitively", () => {
+    expect(
+      filterBookmarkRows(rows, "WEEKLY").map((r) => r.bookmark.id),
+    ).toEqual(["1"]);
+    expect(
+      filterBookmarkRows(rows, "publishers").map((r) => r.bookmark.id),
+    ).toEqual(["2"]);
+    expect(
+      filterBookmarkRows(rows, "programmatic").map((r) => r.bookmark.id),
+    ).toEqual(["1", "2"]);
+    expect(
+      filterBookmarkRows(rows, "overview_canvas").map((r) => r.bookmark.id),
+    ).toEqual(["3"]);
+  });
+});
diff --git a/web-admin/src/features/bookmarks/listing/bookmark-listing-utils.ts b/web-admin/src/features/bookmarks/listing/bookmark-listing-utils.ts
new file mode 100644
index 000000000000..4bde94b641ee
--- /dev/null
+++ b/web-admin/src/features/bookmarks/listing/bookmark-listing-utils.ts
@@ -0,0 +1,166 @@
+import type { V1Bookmark } from "@rilldata/web-admin/client";
+import { isFilterOnlyBookmark } from "@rilldata/web-admin/features/bookmarks/utils.ts";
+import type { SortOption } from "@rilldata/web-common/components/table-toolbar";
+import { ResourceKind } from "@rilldata/web-common/features/entity-management/resource-selectors";
+import { m } from "@rilldata/web-common/lib/i18n/gen/messages";
+import type { V1Resource } from "@rilldata/web-common/runtime-client";
+
+export type BookmarkCategory = "home" | "managed" | "personal";
+
+export type BookmarkListRow = {
+  bookmark: V1Bookmark;
+  category: BookmarkCategory;
+  // True when the bookmark stores only filter and time range params.
+  filtersOnly: boolean;
+  // Legacy bookmarks store their state as proto data instead of url params.
+  // The manager cannot resolve that state, so they open the dashboard without it.
+  // The bookmark dropdown on the dashboard still resolves it.
+  isLegacy: boolean;
+  // Kind of the dashboard the bookmark is for. Undefined for kinds the manager cannot open.
+  dashboardKind: ResourceKind.Explore | ResourceKind.Canvas | undefined;
+  // Display name of the dashboard. Falls back to the resource name when the dashboard is not among the project's resources.
+  dashboardTitle: string;
+  // Opens the bookmark on its dashboard. Undefined when the dashboard kind is unknown.
+  href: string | undefined;
+  // The owner may manage personal bookmarks; managed and home bookmarks need the manage bookmarks permission.
+  canManage: boolean;
+  // Epoch milliseconds of the last time the bookmark was opened in this browser. Zero when never opened.
+  lastUsed: number;
+};
+
+const DashboardSlugByKind: Partial<Record<string, "explore" | "canvas">> = {
+  [ResourceKind.Explore]: "explore",
+  [ResourceKind.Canvas]: "canvas",
+};
+
+export function buildBookmarkRows({
+  bookmarks,
+  dashboards,
+  organization,
+  project,
+  currentUserId,
+  manageBookmarks,
+  recentlyUsed,
+}: {
+  bookmarks: V1Bookmark[];
+  dashboards: V1Resource[];
+  organization: string;
+  project: string;
+  currentUserId: string | undefined;
+  manageBookmarks: boolean;
+  // Bookmark id to epoch milliseconds, see RecentlyUsedBookmarks.
+  recentlyUsed: Record<string, number>;
+}): BookmarkListRow[] {
+  const dashboardTitles = new Map<string, string>();
+  for (const resource of dashboards) {
+    const kind = resource.meta?.name?.kind;
+    const name = resource.meta?.name?.name;
+    if (!kind || !name) continue;
+    const title =
+      resource.explore?.spec?.displayName ?? resource.canvas?.spec?.displayName;
+    dashboardTitles.set(dashboardKey(kind, name), title || name);
+  }
+
+  return bookmarks.map((bookmark) => {
+    const kind = bookmark.resourceKind ?? "";
+    const name = bookmark.resourceName ?? "";
+    const slug = DashboardSlugByKind[kind];
+    const urlSearch = normalizeUrlSearch(bookmark.urlSearch);
+    const isLegacy = !urlSearch && !!bookmark.data;
+    const category: BookmarkCategory = bookmark.default
+      ? "home"
+      : bookmark.shared
+        ? "managed"
+        : "personal";
+
+    return {
+      bookmark,
+      category,
+      filtersOnly:
+        !isLegacy && isFilterOnlyBookmark(new URLSearchParams(urlSearch)),
+      isLegacy,
+      dashboardKind: slug
+        ? (kind as ResourceKind.Explore | ResourceKind.Canvas)
+        : undefined,
+      dashboardTitle: dashboardTitles.get(dashboardKey(kind, name)) ?? name,
+      href: slug
+        ? `/${organization}/${project}/${slug}/${name}${urlSearch}`
+        : undefined,
+      canManage:
+        category === "personal"
+          ? !!currentUserId && bookmark.userId === currentUserId
+          : manageBookmarks,
+      lastUsed: bookmark.id ? (recentlyUsed[bookmark.id] ?? 0) : 0,
+    };
+  });
+}
+
+export function filterBookmarkRows(
+  rows: BookmarkListRow[],
+  searchText: string,
+): BookmarkListRow[] {
+  const search = searchText.trim().toLowerCase();
+  if (!search) return rows;
+  return rows.filter((row) =>
+    [
+      row.bookmark.displayName,
+      row.bookmark.description,
+      row.dashboardTitle,
+      row.bookmark.resourceName,
+    ].some((text) => text?.toLowerCase().includes(search)),
+  );
+}
+
+// Column ids refer to the hidden accessor columns declared in BookmarksTable.svelte.
+export const BookmarkTableSortOptions: SortOption[] = [
+  {
+    value: "last_used_desc",
+    get label() {
+      return m.bookmark_sort_last_used();
+    },
+    sort: {
+      id: "lastUsed",
+      desc: true,
+    },
+  },
+  {
+    value: "updated_desc",
+    get label() {
+      return m.bookmark_sort_last_updated();
+    },
+    sort: {
+      id: "updatedOn",
+      desc: true,
+    },
+  },
+  {
+    value: "name_asc",
+    get label() {
+      return m.bookmark_sort_name();
+    },
+    sort: {
+      id: "name",
+      desc: false,
+    },
+  },
+  {
+    value: "dashboard_asc",
+    get label() {
+      return m.bookmark_sort_dashboard();
+    },
+    sort: {
+      id: "dashboard",
+      desc: false,
+    },
+  },
+];
+
+function dashboardKey(kind: string, name: string) {
+  return `${kind}:${name.toLowerCase()}`;
+}
+
+// Bookmarks created through the UI store the search with a leading "?"; tolerate ones that do not.
+function normalizeUrlSearch(urlSearch: string | undefined) {
+  if (!urlSearch) return "";
+  return urlSearch.startsWith("?") ? urlSearch : `?${urlSearch}`;
+}
diff --git a/web-admin/src/features/bookmarks/recently-used-bookmarks.ts b/web-admin/src/features/bookmarks/recently-used-bookmarks.ts
new file mode 100644
index 000000000000..396ca3688ea9
--- /dev/null
+++ b/web-admin/src/features/bookmarks/recently-used-bookmarks.ts
@@ -0,0 +1,27 @@
+import { SvelteLocalStorage } from "@rilldata/web-common/lib/store-utils/svelte-local-storage.svelte.ts";
+
+/**
+ * Tracks when each bookmark was last opened, per project, in local storage.
+ * Mirrors RecentlyUsedDashboards: usage is a per-browser signal, not synced to the server.
+ */
+export class RecentlyUsedBookmarks {
+  // Bookmark id to epoch milliseconds of the last time it was opened.
+  public readonly recentlyUsed: SvelteLocalStorage<
+    Record<string, number>,
+    Record<string, number>
+  >;
+
+  public constructor(org: string, project: string) {
+    this.recentlyUsed = SvelteLocalStorage.createJsonStore<
+      Record<string, number>
+    >(`rill:app:${org}:${project}:bookmark:recentlyUsed`, {});
+  }
+
+  public update(bookmarkId: string | undefined) {
+    if (!bookmarkId) return;
+    this.recentlyUsed.setter({
+      ...this.recentlyUsed.value,
+      [bookmarkId]: Date.now(),
+    });
+  }
+}
diff --git a/web-admin/src/features/bookmarks/selectors.ts b/web-admin/src/features/bookmarks/selectors.ts
index 8d7c29d809d4..2a174086d849 100644
--- a/web-admin/src/features/bookmarks/selectors.ts
+++ b/web-admin/src/features/bookmarks/selectors.ts
@@ -2,6 +2,7 @@ import { page } from "$app/stores";
 import {
   createAdminServiceGetCurrentUser,
   createAdminServiceListBookmarks,
+  getAdminServiceListBookmarksQueryKey,
   getAdminServiceListBookmarksQueryOptions,
   type V1Bookmark,
   type V1ListBookmarksResponse,
@@ -62,6 +63,44 @@ export function getBookmarksQueryOptions(
   );
 }
 
+/**
+ * Query options for every bookmark in the project that is visible to the current user.
+ * This powers the bookmark manager; the dashboard dropdowns use {@link getBookmarksQueryOptions} scoped to one resource.
+ */
+export function getProjectBookmarksQueryOptions(
+  orgAndProjectNameStore: OrgAndProjectNameStore,
+) {
+  const projectIdQuery = createQuery(
+    getProjectIdQueryOptions(orgAndProjectNameStore),
+  );
+
+  return derived(
+    [createAdminServiceGetCurrentUser(), projectIdQuery],
+    ([userResp, projectIdQueryResp]) => {
+      const projectId = projectIdQueryResp.data;
+
+      return getAdminServiceListBookmarksQueryOptions(
+        { projectId },
+        {
+          query: {
+            enabled: Boolean(userResp.data?.user && projectId),
+          },
+        },
+      );
+    },
+  );
+}
+
+/**
+ * Invalidates every bookmarks list query: the per-dashboard ones behind the bookmark dropdowns and the project-wide one behind the bookmark manager.
+ * The generated query keys are `["/v1/users/bookmarks", params]`, so the param-less key prefix-matches all of them.
+ */
+export function invalidateBookmarkQueries() {
+  return queryClient.invalidateQueries({
+    queryKey: getAdminServiceListBookmarksQueryKey(),
+  });
+}
+
 export function getBookmarks(
   projectId: string,
   resourceKind: ResourceKind,
diff --git a/web-admin/src/features/bookmarks/utils.ts b/web-admin/src/features/bookmarks/utils.ts
index 5f5d0cf0d084..a89bb3200fd1 100644
--- a/web-admin/src/features/bookmarks/utils.ts
+++ b/web-admin/src/features/bookmarks/utils.ts
@@ -231,7 +231,9 @@ function isAbsoluteTimeRangeBookmark(bookmarkUrlParams: URLSearchParams) {
   }
 }
 
-function isFilterOnlyBookmark(bookmarkUrlParams: URLSearchParams): boolean {
+export function isFilterOnlyBookmark(
+  bookmarkUrlParams: URLSearchParams,
+): boolean {
   const urlParams = Array.from(bookmarkUrlParams.keys());
   return urlParams.every((param) => FILTER_ONLY_PARAMS.has(param));
 }
diff --git a/web-admin/src/features/projects/ProjectTabs.svelte b/web-admin/src/features/projects/ProjectTabs.svelte
index 5709f1a91085..80a4f837ba13 100644
--- a/web-admin/src/features/projects/ProjectTabs.svelte
+++ b/web-admin/src/features/projects/ProjectTabs.svelte
@@ -14,6 +14,8 @@
   export let project: string;
   export let pathname: string;
   export let branchPrefix: string = "";
+  // Bookmarks belong to users, so anonymous viewers of public projects have none to manage.
+  export let hasUser: boolean = false;
 
   const { chat, reports, alerts } = featureFlags;
 
@@ -33,6 +35,11 @@
       label: m.nav_tab_dashboards(),
       hasPermission: true,
     },
+    {
+      route: `/${organization}/${project}${branchPrefix}/-/bookmarks`,
+      label: m.nav_tab_bookmarks(),
+      hasPermission: hasUser,
+    },
     {
       route: `/${organization}/${project}${branchPrefix}/-/query`,
       label: m.nav_tab_query(),
diff --git a/web-admin/src/features/resources/ResourceList.svelte b/web-admin/src/features/resources/ResourceList.svelte
index c0bae7b702f4..0be3d82c608f 100644
--- a/web-admin/src/features/resources/ResourceList.svelte
+++ b/web-admin/src/features/resources/ResourceList.svelte
@@ -26,6 +26,9 @@
   export let sorting: SortingState = [];
   export let pinnedRows: string[] = [];
   export let maxRows: number | undefined = undefined;
+  // Defaults to the resource name, which is only meaningful for runtime resources.
+  export let getRowId: ((row: unknown, index: number) => string) | undefined =
+    undefined;
 
   function setSorting(newSorting: SortingState) {
     options.update((old) => ({
@@ -65,6 +68,7 @@
       rowPinning: {},
     },
     getRowId(originalRow, index) {
+      if (getRowId) return getRowId(originalRow, index);
       return (
         (originalRow as V1Resource).meta?.name?.name?.toLowerCase() ??
         index.toString()
diff --git a/web-admin/src/routes/[organization]/[project]/+layout.svelte b/web-admin/src/routes/[organization]/[project]/+layout.svelte
index 8cd82df4239f..53fdaeb05314 100644
--- a/web-admin/src/routes/[organization]/[project]/+layout.svelte
+++ b/web-admin/src/routes/[organization]/[project]/+layout.svelte
@@ -356,6 +356,7 @@
               pathname={page.url.pathname}
               {project}
               {branchPrefix}
+              hasUser={!!$user.data?.user}
             />
           {/if}
         {/if}
diff --git a/web-admin/src/routes/[organization]/[project]/+page.svelte b/web-admin/src/routes/[organization]/[project]/+page.svelte
index 63d1e8922fa3..56edff659626 100644
--- a/web-admin/src/routes/[organization]/[project]/+page.svelte
+++ b/web-admin/src/routes/[organization]/[project]/+page.svelte
@@ -17,6 +17,9 @@
   import { escapeHtml } from "@rilldata/web-common/lib/i18n";
   import TableToolbarSort from "@rilldata/web-common/components/table-toolbar/TableToolbarSort.svelte";
   import { DashboardTableSortOptions } from "../../../features/dashboards/listing/dashboard-favourites.ts";
+  import { createAdminServiceGetCurrentUser } from "@rilldata/web-admin/client";
+  import BookmarksTable from "@rilldata/web-admin/features/bookmarks/listing/BookmarksTable.svelte";
+  import { BookmarkTableSortOptions } from "@rilldata/web-admin/features/bookmarks/listing/bookmark-listing-utils.ts";
 
   const { chat, personalCanvases } = featureFlags;
 
@@ -48,6 +51,15 @@
     "sort",
     DashboardTableSortOptions[0].value,
   );
+
+  // Bookmarks belong to users, so the section is hidden for anonymous viewers of public projects.
+  const user = createAdminServiceGetCurrentUser();
+  $: hasUser = !!$user.data?.user;
+  // Separate param from the dashboards sort above so the two sections sort independently.
+  const bookmarksSortStore = UrlParamsState.createStringParam(
+    "bookmarks_sort",
+    BookmarkTableSortOptions[0].value,
+  );
 </script>
 
 <svelte:head>
@@ -126,5 +138,30 @@
       </h2>
       <DashboardsTable isPreview previewLimit={5} />
     </div>
+
+    <!-- Bookmarks Section -->
+    {#if hasUser}
+      <div class="flex flex-col gap-y-4">
+        <h2
+          class="flex flex-row gap-x-2 items-center text-xl font-semibold text-fg-secondary"
+        >
+          <div class="flex flex-row w-full gap-x-2 items-center grow">
+            <span>{m.home_bookmarks_heading()}</span>
+            <TableToolbarSort
+              sortStore={bookmarksSortStore}
+              sortOptions={BookmarkTableSortOptions}
+              size="sm"
+              noOutline
+            />
+            <div class="grow"></div>
+          </div>
+        </h2>
+        <BookmarksTable
+          isPreview
+          previewLimit={5}
+          sortStore={bookmarksSortStore}
+        />
+      </div>
+    {/if}
   </div>
 </ContentContainer>
diff --git a/web-admin/src/routes/[organization]/[project]/-/bookmarks/+page.svelte b/web-admin/src/routes/[organization]/[project]/-/bookmarks/+page.svelte
new file mode 100644
index 000000000000..3eccfaa78250
--- /dev/null
+++ b/web-admin/src/routes/[organization]/[project]/-/bookmarks/+page.svelte
@@ -0,0 +1,18 @@
+<script lang="ts">
+  import { page } from "$app/state";
+  import BookmarksTable from "@rilldata/web-admin/features/bookmarks/listing/BookmarksTable.svelte";
+  import ContentContainer from "@rilldata/web-common/components/layout/ContentContainer.svelte";
+  import { m } from "@rilldata/web-common/lib/i18n/gen/messages";
+
+  let { project } = $derived(page.params);
+</script>
+
+<svelte:head>
+  <title>{m.project_bookmarks_page_title({ project })}</title>
+</svelte:head>
+
+<ContentContainer maxWidth={800} title={m.project_bookmarks_title()}>
+  <div class="flex flex-col items-center gap-y-4">
+    <BookmarksTable />
+  </div>
+</ContentContainer>
diff --git a/web-admin/tests/bookmarks-manager.spec.ts b/web-admin/tests/bookmarks-manager.spec.ts
new file mode 100644
index 000000000000..bd63e9251663
--- /dev/null
+++ b/web-admin/tests/bookmarks-manager.spec.ts
@@ -0,0 +1,125 @@
+import { expect } from "@playwright/test";
+import { interactWithTimeRangeMenu } from "@rilldata/web-common/tests/utils/explore-interactions";
+import { test } from "./setup/base";
+
+const BOOKMARK_NAME = "Manager bookmark";
+const BOOKMARK_DESCRIPTION = "Created for the bookmark manager test.";
+const RENAMED_BOOKMARK_NAME = "Manager bookmark renamed";
+
+test.describe.serial("Bookmark manager", () => {
+  test("Create a bookmark from a dashboard", async ({ adminPage }) => {
+    await adminPage.goto("/e2e/openrtb/explore/auction_explore_bookmarks");
+
+    await interactWithTimeRangeMenu(adminPage, async () => {
+      await adminPage.getByRole("menuitem", { name: "Last 6 Hours" }).click();
+    });
+
+    await adminPage.getByLabel("Other bookmark dropdown").click();
+    await adminPage
+      .getByRole("menuitem", { name: "Bookmark current view", exact: true })
+      .click();
+    await adminPage.getByTitle("Label").fill(BOOKMARK_NAME);
+    await adminPage.getByTitle("Description").fill(BOOKMARK_DESCRIPTION);
+    await adminPage.getByRole("button", { name: "Save" }).click();
+    await expect(adminPage.getByText("Bookmark created")).toBeVisible();
+  });
+
+  test("Project home lists bookmarks and sorts them", async ({ adminPage }) => {
+    await adminPage.goto("/e2e/openrtb");
+
+    await expect(
+      adminPage.getByRole("heading", { name: /^Bookmarks/ }),
+    ).toBeVisible();
+    const entry = adminPage.getByLabel(`${BOOKMARK_NAME} Bookmark Entry`);
+    await expect(entry).toBeVisible();
+    await expect(entry).toContainText(BOOKMARK_DESCRIPTION);
+    await expect(entry).toContainText("Updated");
+
+    // The bookmarks sort is independent of the dashboards sort on the same page.
+    const bookmarksHeading = adminPage.getByRole("heading", {
+      name: /^Bookmarks/,
+    });
+    await bookmarksHeading
+      .getByRole("button", { name: "Sort by Last used" })
+      .click();
+    await adminPage.getByRole("menuitemcheckbox", { name: "Name" }).click();
+    await expect(adminPage).toHaveURL(/bookmarks_sort=name_asc/);
+    await expect(
+      bookmarksHeading.getByRole("button", { name: "Sort by Name" }),
+    ).toBeVisible();
+    await expect(
+      adminPage
+        .getByRole("heading", { name: /^Dashboards/ })
+        .getByRole("button", { name: "Sort by Last Used" }),
+    ).toBeVisible();
+  });
+
+  test("Bookmarks page supports search, edit, open and delete", async ({
+    adminPage,
+  }) => {
+    await adminPage.goto("/e2e/openrtb");
+    await adminPage
+      .getByRole("link", { name: "Bookmarks", exact: true })
+      .click();
+    await expect(adminPage.getByLabel("Container title")).toHaveText(
+      "Project bookmarks",
+    );
+
+    const entry = adminPage.getByLabel(`${BOOKMARK_NAME} Bookmark Entry`);
+    await expect(entry).toBeVisible();
+
+    // Search matches the name and reports when nothing matches.
+    const search = adminPage.getByPlaceholder("Search...");
+    await search.fill("no such bookmark");
+    await expect(
+      adminPage.getByText("No bookmarks match your search"),
+    ).toBeVisible();
+    await search.fill("manager");
+    await expect(entry).toBeVisible();
+    await search.fill("");
+
+    // Edit the name from the manager.
+    await entry.hover();
+    await adminPage.getByRole("button", { name: "Edit bookmark" }).click();
+    await adminPage.getByTitle("Label").fill(RENAMED_BOOKMARK_NAME);
+    await adminPage.getByRole("button", { name: "Save" }).click();
+    await expect(adminPage.getByText("Bookmark updated")).toBeVisible();
+    const renamedEntry = adminPage.getByLabel(
+      `${RENAMED_BOOKMARK_NAME} Bookmark Entry`,
+    );
+    await expect(renamedEntry).toBeVisible();
+
+    // Opening the bookmark restores its state on the dashboard.
+    await renamedEntry.click();
+    await expect(adminPage).toHaveURL(
+      /\/e2e\/openrtb\/explore\/auction_explore_bookmarks\?/,
+    );
+    await expect(adminPage.getByText("Last 6 Hours")).toBeVisible();
+
+    // Opening it recorded a last used time for this browser.
+    await adminPage.goto("/e2e/openrtb/-/bookmarks");
+    await expect(renamedEntry).toContainText("Last used");
+
+    // Delete with confirmation.
+    await renamedEntry.hover();
+    await adminPage.getByRole("button", { name: "Delete bookmark" }).click();
+    await adminPage
+      .getByRole("button", { name: "Delete", exact: true })
+      .click();
+    await expect(
+      adminPage.getByText(`Bookmark ${RENAMED_BOOKMARK_NAME} deleted`),
+    ).toBeVisible();
+    await expect(renamedEntry).not.toBeVisible();
+
+    // The dashboard's bookmark dropdown no longer lists it either.
+    await adminPage.goto("/e2e/openrtb/explore/auction_explore_bookmarks");
+    await adminPage.getByLabel("Other bookmark dropdown").click();
+    await expect(
+      adminPage.getByRole("menuitem", {
+        name: "Bookmark current view",
+        exact: true,
+      }),
+    ).toBeVisible();
+    await expect(renamedEntry).not.toBeVisible();
+  });
+});
diff --git a/web-common/src/lib/i18n/messages/en.json b/web-common/src/lib/i18n/messages/en.json
index 814248eab124..cde933f1ba61 100644
--- a/web-common/src/lib/i18n/messages/en.json
+++ b/web-common/src/lib/i18n/messages/en.json
@@ -297,10 +297,14 @@
   "bookmark_current_view_as_home": "Bookmark current view as Home.",
   "bookmark_default_label": "Default Label",
   "bookmark_delete_bookmark": "Delete bookmark",
+  "bookmark_delete_confirm_description": "This will permanently delete the bookmark \"{name}\".",
+  "bookmark_delete_confirm_title": "Delete bookmark?",
   "bookmark_delete_home_bookmark": "Delete Home bookmark",
   "bookmark_deleted": "Bookmark {name} deleted",
   "bookmark_description": "Description",
   "bookmark_edit": "Edit bookmark",
+  "bookmark_edit_filters_on_dashboard": "Open it on the dashboard to change its filters.",
+  "bookmark_entry_aria_label": "{name} Bookmark Entry",
   "bookmark_filters": "Filters",
   "bookmark_filters_inherited": "Inherited from underlying dashboard view.",
   "bookmark_filters_only_tooltip": "Toggling this on will only save the filter set above, not the full dashboard layout and state.",
@@ -312,6 +316,12 @@
   "bookmark_home_dropdown_label": "Home bookmark dropdown",
   "bookmark_home_entry_aria_label": "Home Bookmark Entry",
   "bookmark_label": "Label",
+  "bookmark_last_used_ago": "Last used {time}",
+  "bookmark_legacy_tooltip": "Saved with an older version of Rill. Open it from the dashboard's bookmark menu to restore its full state.",
+  "bookmark_list_empty": "You don't have any bookmarks yet",
+  "bookmark_list_empty_action": "Open a dashboard and use its bookmark menu to save a view",
+  "bookmark_list_no_match": "No bookmarks match your search",
+  "bookmark_list_see_all": "See all bookmarks",
   "bookmark_managed_bookmarks": "Managed bookmarks",
   "bookmark_no_bookmarks": "You have no bookmarks for this dashboard.",
   "bookmark_no_shared": "There are no shared bookmarks for this dashboard.",
@@ -319,7 +329,15 @@
   "bookmark_return_to_home": "Return to dashboard home",
   "bookmark_save": "Save",
   "bookmark_save_filters_only": "Save filters only",
+  "bookmark_sort_dashboard": "Dashboard",
+  "bookmark_sort_last_updated": "Last updated",
+  "bookmark_sort_last_used": "Last used",
+  "bookmark_sort_name": "Name",
+  "bookmark_tag_home": "Home",
+  "bookmark_tag_legacy": "Legacy",
+  "bookmark_tag_managed": "Managed",
   "bookmark_updated": "Bookmark updated",
+  "bookmark_updated_ago": "Updated {time}",
   "bookmark_your_bookmarks": "Your bookmarks",
   "branch_add_from_cli": "Add a branch from the CLI:",
   "branch_author": "Author",
@@ -1335,6 +1353,7 @@
     }
   ],
   "groups_yes_delete": "Yes, delete",
+  "home_bookmarks_heading": "Bookmarks",
   "home_dashboards_heading": "Dashboards",
   "home_greeting": "Hi {name}!",
   "home_page_title": "Home - Rill",
@@ -1404,6 +1423,7 @@
   "nav_status": "Status",
   "nav_tab_ai": "AI",
   "nav_tab_alerts": "Alerts",
+  "nav_tab_bookmarks": "Bookmarks",
   "nav_tab_dashboards": "Dashboards",
   "nav_tab_home": "Home",
   "nav_tab_query": "Query",
@@ -1501,6 +1521,8 @@
   "personal_files_share_shared_message": "This dashboard is shared with all users in the project.",
   "personal_files_share_shared_notification": "Dashboard shared successfully",
   "personal_files_share_tooltip": "Share dashboard",
+  "project_bookmarks_page_title": "{project} bookmarks - Rill",
+  "project_bookmarks_title": "Project bookmarks",
   "project_branch_hibernated": "Branch hibernated",
   "project_branch_is_hibernated": "This branch is hibernated.",
   "project_card_visibility_private": "This project is private",
diff --git a/web-common/src/lib/i18n/messages/es.json b/web-common/src/lib/i18n/messages/es.json
index f924d2871eb5..35ae14de6667 100644
--- a/web-common/src/lib/i18n/messages/es.json
+++ b/web-common/src/lib/i18n/messages/es.json
@@ -297,10 +297,14 @@
   "bookmark_current_view_as_home": "Guardar vista actual como Inicio.",
   "bookmark_default_label": "Etiqueta predeterminada",
   "bookmark_delete_bookmark": "Eliminar marcador",
+  "bookmark_delete_confirm_description": "Esto eliminará permanentemente el marcador \"{name}\".",
+  "bookmark_delete_confirm_title": "¿Eliminar marcador?",
   "bookmark_delete_home_bookmark": "Eliminar marcador de Inicio",
   "bookmark_deleted": "Marcador {name} eliminado",
   "bookmark_description": "Descripción",
   "bookmark_edit": "Editar marcador",
+  "bookmark_edit_filters_on_dashboard": "Ábrelo en el dashboard para cambiar sus filtros.",
+  "bookmark_entry_aria_label": "Entrada de marcador {name}",
   "bookmark_filters": "Filtros",
   "bookmark_filters_inherited": "Heredado de la vista del dashboard subyacente.",
   "bookmark_filters_only_tooltip": "Activar esto solo guardará el conjunto de filtros anterior, no el diseño y estado completo del dashboard.",
@@ -312,6 +316,12 @@
   "bookmark_home_dropdown_label": "Menú desplegable del marcador de Inicio",
   "bookmark_home_entry_aria_label": "Entrada del marcador de Inicio",
   "bookmark_label": "Etiqueta",
+  "bookmark_last_used_ago": "Usado por última vez {time}",
+  "bookmark_legacy_tooltip": "Guardado con una versión anterior de Rill. Ábrelo desde el menú de marcadores del dashboard para restaurar su estado completo.",
+  "bookmark_list_empty": "Aún no tienes marcadores",
+  "bookmark_list_empty_action": "Abre un dashboard y usa su menú de marcadores para guardar una vista",
+  "bookmark_list_no_match": "Ningún marcador coincide con tu búsqueda",
+  "bookmark_list_see_all": "Ver todos los marcadores",
   "bookmark_managed_bookmarks": "Marcadores gestionados",
   "bookmark_no_bookmarks": "No tienes marcadores para este dashboard.",
   "bookmark_no_shared": "No hay marcadores compartidos para este dashboard.",
@@ -319,7 +329,15 @@
   "bookmark_return_to_home": "Volver al inicio del dashboard",
   "bookmark_save": "Guardar",
   "bookmark_save_filters_only": "Guardar solo filtros",
+  "bookmark_sort_dashboard": "Dashboard",
+  "bookmark_sort_last_updated": "Última actualización",
+  "bookmark_sort_last_used": "Último uso",
+  "bookmark_sort_name": "Nombre",
+  "bookmark_tag_home": "Inicio",
+  "bookmark_tag_legacy": "Heredado",
+  "bookmark_tag_managed": "Gestionado",
   "bookmark_updated": "Marcador actualizado",
+  "bookmark_updated_ago": "Actualizado {time}",
   "bookmark_your_bookmarks": "Tus marcadores",
   "branch_add_from_cli": "Agrega una rama desde la CLI:",
   "branch_author": "Autor",
@@ -1344,6 +1362,7 @@
     }
   ],
   "groups_yes_delete": "Sí, eliminar",
+  "home_bookmarks_heading": "Marcadores",
   "home_dashboards_heading": "Dashboards",
   "home_greeting": "¡Hola {name}!",
   "home_page_title": "Inicio - Rill",
@@ -1413,6 +1432,7 @@
   "nav_status": "Estado",
   "nav_tab_ai": "IA",
   "nav_tab_alerts": "Alertas",
+  "nav_tab_bookmarks": "Marcadores",
   "nav_tab_dashboards": "Dashboards",
   "nav_tab_home": "Inicio",
   "nav_tab_query": "Consulta",
@@ -1510,6 +1530,8 @@
   "personal_files_share_shared_message": "Este dashboard está compartido con todos los usuarios del proyecto.",
   "personal_files_share_shared_notification": "Dashboard compartido correctamente",
   "personal_files_share_tooltip": "Compartir dashboard",
+  "project_bookmarks_page_title": "Marcadores de {project} - Rill",
+  "project_bookmarks_title": "Marcadores del proyecto",
   "project_branch_hibernated": "Rama en hibernación",
   "project_branch_is_hibernated": "Esta rama está en hibernación.",
   "project_card_visibility_private": "Este proyecto es privado",
diff --git a/web-common/src/lib/store-utils/url-params-state.svelte.spec.ts b/web-common/src/lib/store-utils/url-params-state.svelte.spec.ts
index 6165f076bcd7..35a09466624e 100644
--- a/web-common/src/lib/store-utils/url-params-state.svelte.spec.ts
+++ b/web-common/src/lib/store-utils/url-params-state.svelte.spec.ts
@@ -45,7 +45,7 @@ describe("UrlParamsState", () => {
   });
 
   it("updates the value optimistically before the URL write is flushed", async () => {
-    let q!: UrlParamsState<string, null>;
+    let q!: UrlParamsState<string, string>;
     const cleanup = $effect.root(() => {
       q = UrlParamsState.createStringParam("q");
     });
@@ -67,7 +67,7 @@ describe("UrlParamsState", () => {
   });
 
   it("batches writes from multiple stores into a single navigation", async () => {
-    let q!: UrlParamsState<string, null>;
+    let q!: UrlParamsState<string, string>;
     let status!: ArrayRuneStore<string>;
     const cleanup = $effect.root(() => {
       q = UrlParamsState.createStringParam("q");
@@ -87,7 +87,7 @@ describe("UrlParamsState", () => {
 
   it("removes the param when set to the empty/default value", async () => {
     page.url = new URL("http://localhost/?q=hello");
-    let q!: UrlParamsState<string, null>;
+    let q!: UrlParamsState<string, string>;
     const cleanup = $effect.root(() => {
       q = UrlParamsState.createStringParam("q");
     });
diff --git a/web-common/src/lib/store-utils/url-params-state.svelte.ts b/web-common/src/lib/store-utils/url-params-state.svelte.ts
index b1b1cfa32dad..b3b966b839d0 100644
--- a/web-common/src/lib/store-utils/url-params-state.svelte.ts
+++ b/web-common/src/lib/store-utils/url-params-state.svelte.ts
@@ -34,7 +34,7 @@ export class UrlParamsState<Val, DefaultVal>
   }
 
   public static createStringParam(param: string, defaultValue: string = "") {
-    return new UrlParamsState<string, null>(
+    return new UrlParamsState<string, string>(
       param,
       (value) => (value === "" ? null : value),
       (value) => value ?? defaultValue,
diff --git a/web-common/src/proto/gen/rill/admin/v1/api_pb.ts b/web-common/src/proto/gen/rill/admin/v1/api_pb.ts
index 12461e4fc5bf..d510075a30ee 100644
--- a/web-common/src/proto/gen/rill/admin/v1/api_pb.ts
+++ b/web-common/src/proto/gen/rill/admin/v1/api_pb.ts
@@ -10214,6 +10214,9 @@ export class RevokeCurrentAuthTokenResponse extends Message<RevokeCurrentAuthTok
 }
 
 /**
+ * ListBookmarksRequest lists the bookmarks in a project that are visible to the caller:
+ * the caller's own bookmarks plus shared and default bookmarks.
+ *
  * @generated from message rill.admin.v1.ListBookmarksRequest
  */
 export class ListBookmarksRequest extends Message<ListBookmarksRequest> {
@@ -10223,11 +10226,16 @@ export class ListBookmarksRequest extends Message<ListBookmarksRequest> {
   projectId = "";
 
   /**
+   * Optional filter on the kind of the resource the bookmark is for (e.g. "rill.runtime.v1.Explore").
+   * When both resource_kind and resource_name are empty, all bookmarks in the project are returned.
+   *
    * @generated from field: string resource_kind = 2;
    */
   resourceKind = "";
 
   /**
+   * Optional filter on the name of the resource the bookmark is for. Requires resource_kind to be set.
+   *
    * @generated from field: string resource_name = 3;
    */
   resourceName = "";