diff --git a/e2e/tests/urlParams.spec.ts b/e2e/tests/urlParams.spec.ts
new file mode 100644
index 000000000..bdb9e8f7e
--- /dev/null
+++ b/e2e/tests/urlParams.spec.ts
@@ -0,0 +1,351 @@
+import { expect, test } from "@playwright/test";
+import { clientUrl, registerNewUser, registerDandiset } from "../utils.ts";
+import { faker } from "@faker-js/faker";
+
+/**
+ * Tests that listing query parameters (page, sortOption, sortDir, showDrafts,
+ * showEmpty, search) do not leak into Dandiset Landing Page (DLP) URLs,
+ * and vice-versa.  Note: ?pos= IS allowed on DLP URLs (position in result set).
+ * See https://github.com/dandi/dandi-archive/issues/1460
+ */
+
+// These listing-specific params must NOT appear on DLP URLs.
+// Note: 'pos' and 'search' are allowed — pos for result set position, search for context.
+const LISTING_PARAMS = ["page", "sortOption", "sortDir", "showDrafts", "showEmpty"];
+
+/** Assert that none of the listing-specific params appear in the current URL. */
+function expectNoLeakedParams(url: string) {
+  const parsed = new URL(url);
+  for (const param of LISTING_PARAMS) {
+    expect(parsed.searchParams.has(param), `URL should not contain '${param}': ${url}`).toBeFalsy();
+  }
+}
+
+test.describe("URL parameter isolation (issue #1460)", () => {
+  test("listing params do not leak to DLP when clicking a dandiset", async ({ page }) => {
+    await registerNewUser(page);
+    const name = faker.lorem.words();
+    const description = faker.lorem.sentences();
+    await registerDandiset(page, name, description);
+
+    // Go to the public dandisets listing
+    await page.goto(`${clientUrl}/dandiset`);
+    await page.waitForLoadState("networkidle");
+
+    // Click the first dandiset in the list
+    await page.locator(".v-list-item").first().click();
+    await page.waitForLoadState("networkidle");
+
+    // DLP URL must not contain listing params
+    expectNoLeakedParams(page.url());
+    // Should be on a dandiset page with pos param
+    expect(page.url()).toMatch(/\/dandiset\/\d+/);
+    const url = new URL(page.url());
+    expect(url.searchParams.has("pos")).toBeTruthy();
+  });
+
+  test("search context is preserved but listing params do not leak to DLP", async ({ page }) => {
+    await registerNewUser(page);
+    const name = `searchtest-${faker.lorem.word()}`;
+    const description = faker.lorem.sentences();
+    await registerDandiset(page, name, description);
+
+    // Navigate to search with a query
+    await page.goto(`${clientUrl}/dandiset/search?search=${name}`);
+    await page.waitForLoadState("networkidle");
+
+    // Verify search results appear
+    const items = page.locator(".v-list-item");
+    await expect(items.first()).toBeVisible();
+
+    // Click the first result
+    await items.first().click();
+    await page.waitForLoadState("networkidle");
+
+    // DLP URL must not have listing params
+    expectNoLeakedParams(page.url());
+    // But search and pos should be present for context
+    const url = new URL(page.url());
+    expect(url.searchParams.get("search")).toBe(name);
+    expect(url.searchParams.has("pos")).toBeTruthy();
+  });
+
+  test("direct DLP navigation produces clean URL", async ({ page }) => {
+    await registerNewUser(page);
+    const name = faker.lorem.words();
+    const description = faker.lorem.sentences();
+    const dandisetId = await registerDandiset(page, name, description);
+
+    // Navigate directly to the DLP
+    await page.goto(`${clientUrl}/dandiset/${dandisetId}`);
+    await page.waitForLoadState("networkidle");
+
+    expectNoLeakedParams(page.url());
+  });
+
+  test("DLP pagination updates pos but does not add listing params", async ({ page }) => {
+    test.slow();
+    await registerNewUser(page);
+
+    // Create multiple dandisets so pagination has something to page through
+    for (let i = 0; i < 3; i += 1) {
+      await registerDandiset(page, faker.lorem.words(), faker.lorem.sentences());
+    }
+
+    // Go to listing and click a dandiset
+    await page.goto(`${clientUrl}/dandiset`);
+    await page.waitForLoadState("networkidle");
+    await page.locator(".v-list-item").first().click();
+    await page.waitForLoadState("networkidle");
+
+    const initialPos = new URL(page.url()).searchParams.get("pos");
+    expect(initialPos).toBeTruthy();
+
+    // If pagination is visible, click next and verify pos changes but no listing params leak
+    const nextButton = page.locator(".v-pagination__next button");
+    if (await nextButton.isVisible()) {
+      await nextButton.click();
+      await page.waitForLoadState("networkidle");
+      expectNoLeakedParams(page.url());
+      const newPos = new URL(page.url()).searchParams.get("pos");
+      expect(newPos).toBeTruthy();
+      expect(newPos).not.toBe(initialPos);
+    }
+  });
+
+  test("back button from DLP restores listing params", async ({ page }) => {
+    await registerNewUser(page);
+    await registerDandiset(page, faker.lorem.words(), faker.lorem.sentences());
+
+    // Go to listing
+    await page.goto(`${clientUrl}/dandiset`);
+    await page.waitForLoadState("networkidle");
+
+    // Capture listing URL
+    const listingUrl = page.url();
+
+    // Click into a dandiset
+    await page.locator(".v-list-item").first().click();
+    await page.waitForLoadState("networkidle");
+
+    // Go back
+    await page.goBack();
+    await page.waitForLoadState("networkidle");
+
+    // Should be back on listing with its own params intact
+    const backUrl = new URL(page.url());
+    expect(backUrl.pathname).toBe("/dandiset");
+  });
+
+  test("manually appended listing params are stripped from DLP URL", async ({ page }) => {
+    await registerNewUser(page);
+    const name = faker.lorem.words();
+    const description = faker.lorem.sentences();
+    const dandisetId = await registerDandiset(page, name, description);
+
+    // Navigate to DLP with manually injected listing params
+    // pos and search are allowed; page/sortOption/sortDir/showDrafts/showEmpty are not
+    await page.goto(
+      `${clientUrl}/dandiset/${dandisetId}?page=2&sortOption=1&sortDir=-1&showDrafts=true&showEmpty=false&search=test&pos=5`
+    );
+    await page.waitForLoadState("networkidle");
+
+    // The router guard should have stripped listing params but kept pos and search
+    expectNoLeakedParams(page.url());
+    const url = new URL(page.url());
+    expect(url.searchParams.get("pos")).toBe("5");
+    expect(url.searchParams.get("search")).toBe("test");
+  });
+});
+
+test.describe("DLP tab URL state", () => {
+  test("clicking 'How to Cite' tab adds ?tab=how-to-cite to URL", async ({ page }) => {
+    await registerNewUser(page);
+    const dandisetId = await registerDandiset(page, faker.lorem.words(), faker.lorem.sentences());
+
+    await page.goto(`${clientUrl}/dandiset/${dandisetId}`);
+    await page.waitForLoadState("networkidle");
+
+    // URL should have no tab param on Overview (default)
+    expect(new URL(page.url()).searchParams.has("tab")).toBeFalsy();
+
+    // Click "How to Cite" tab
+    await page.getByRole("tab", { name: "How to Cite" }).click();
+    await page.waitForTimeout(500);
+
+    // URL should now have ?tab=how-to-cite
+    const url = new URL(page.url());
+    expect(url.searchParams.get("tab")).toBe("how-to-cite");
+  });
+
+  test("switching back to Overview removes tab param", async ({ page }) => {
+    await registerNewUser(page);
+    const dandisetId = await registerDandiset(page, faker.lorem.words(), faker.lorem.sentences());
+
+    await page.goto(`${clientUrl}/dandiset/${dandisetId}?tab=how-to-cite`);
+    await page.waitForLoadState("networkidle");
+
+    // Should be on How to Cite tab
+    await expect(page.getByText("How to Cite this Dataset")).toBeVisible();
+
+    // Switch to Overview
+    await page.getByRole("tab", { name: "Overview" }).click();
+    await page.waitForTimeout(500);
+
+    // tab param should be gone
+    expect(new URL(page.url()).searchParams.has("tab")).toBeFalsy();
+  });
+
+  test("navigating to ?tab=how-to-cite opens the correct tab", async ({ page }) => {
+    await registerNewUser(page);
+    const dandisetId = await registerDandiset(page, faker.lorem.words(), faker.lorem.sentences());
+
+    // Navigate directly with tab param
+    await page.goto(`${clientUrl}/dandiset/${dandisetId}?tab=how-to-cite`);
+    await page.waitForLoadState("networkidle");
+
+    // The How to Cite content should be visible
+    await expect(page.getByText("How to Cite this Dataset")).toBeVisible();
+  });
+
+  test("tab param survives page reload", async ({ page }) => {
+    await registerNewUser(page);
+    const dandisetId = await registerDandiset(page, faker.lorem.words(), faker.lorem.sentences());
+
+    await page.goto(`${clientUrl}/dandiset/${dandisetId}`);
+    await page.waitForLoadState("networkidle");
+
+    // Click How to Cite
+    await page.getByRole("tab", { name: "How to Cite" }).click();
+    await page.waitForTimeout(500);
+
+    // Reload
+    await page.reload();
+    await page.waitForLoadState("networkidle");
+
+    // Should still be on How to Cite
+    await expect(page.getByText("How to Cite this Dataset")).toBeVisible();
+    expect(new URL(page.url()).searchParams.get("tab")).toBe("how-to-cite");
+  });
+});
+
+test.describe("DLP citation format URL state", () => {
+  test("selecting a citation format adds ?format= to URL", async ({ page }) => {
+    await registerNewUser(page);
+    const dandisetId = await registerDandiset(page, faker.lorem.words(), faker.lorem.sentences());
+
+    await page.goto(`${clientUrl}/dandiset/${dandisetId}?tab=how-to-cite`);
+    await page.waitForLoadState("networkidle");
+
+    // Default (APA) should have no format param
+    expect(new URL(page.url()).searchParams.has("format")).toBeFalsy();
+
+    // Select BibTeX format
+    await page.locator(".citation-format-select").click();
+    await page.getByRole("option", { name: "BibTeX" }).click();
+    await page.waitForTimeout(500);
+
+    const url = new URL(page.url());
+    expect(url.searchParams.get("format")).toBe("bibtex");
+    expect(url.searchParams.get("tab")).toBe("how-to-cite");
+  });
+
+  test("navigating to ?tab=how-to-cite&format=harvard opens correct format", async ({ page }) => {
+    await registerNewUser(page);
+    const dandisetId = await registerDandiset(page, faker.lorem.words(), faker.lorem.sentences());
+
+    await page.goto(`${clientUrl}/dandiset/${dandisetId}?tab=how-to-cite&format=harvard`);
+    await page.waitForLoadState("networkidle");
+
+    // Harvard should be selected in the dropdown
+    await expect(page.locator(".citation-format-select")).toContainText("Harvard");
+  });
+
+  test("citation format survives page reload", async ({ page }) => {
+    await registerNewUser(page);
+    const dandisetId = await registerDandiset(page, faker.lorem.words(), faker.lorem.sentences());
+
+    await page.goto(`${clientUrl}/dandiset/${dandisetId}?tab=how-to-cite`);
+    await page.waitForLoadState("networkidle");
+
+    // Select Harvard
+    await page.locator(".citation-format-select").click();
+    await page.getByRole("option", { name: "Harvard" }).click();
+    await page.waitForTimeout(500);
+
+    // Reload
+    await page.reload();
+    await page.waitForLoadState("networkidle");
+
+    // Should still be on How to Cite with Harvard selected
+    await expect(page.getByText("How to Cite this Dataset")).toBeVisible();
+    await expect(page.locator(".citation-format-select")).toContainText("Harvard");
+    const url = new URL(page.url());
+    expect(url.searchParams.get("tab")).toBe("how-to-cite");
+    expect(url.searchParams.get("format")).toBe("harvard");
+  });
+
+  test("switching back to APA removes format param", async ({ page }) => {
+    await registerNewUser(page);
+    const dandisetId = await registerDandiset(page, faker.lorem.words(), faker.lorem.sentences());
+
+    await page.goto(`${clientUrl}/dandiset/${dandisetId}?tab=how-to-cite&format=bibtex`);
+    await page.waitForLoadState("networkidle");
+
+    // Select APA (default)
+    await page.locator(".citation-format-select").click();
+    await page.getByRole("option", { name: "APA 7th" }).click();
+    await page.waitForTimeout(500);
+
+    // format param should be gone, tab should remain
+    const url = new URL(page.url());
+    expect(url.searchParams.has("format")).toBeFalsy();
+    expect(url.searchParams.get("tab")).toBe("how-to-cite");
+  });
+});
+
+test.describe("DLP meditor overlay URL state", () => {
+  test("opening meditor adds ?overlay=meditor to URL", async ({ page }) => {
+    await registerNewUser(page);
+    await registerDandiset(page, faker.lorem.words(), faker.lorem.sentences());
+    await page.waitForLoadState("networkidle");
+
+    // No overlay param initially
+    expect(new URL(page.url()).searchParams.has("overlay")).toBeFalsy();
+
+    // Click the metadata edit button to open meditor
+    await page.getByText("Metadata", { exact: true }).click();
+    await page.waitForTimeout(500);
+
+    expect(new URL(page.url()).searchParams.get("overlay")).toBe("meditor");
+  });
+
+  test("closing meditor removes overlay param", async ({ page }) => {
+    await registerNewUser(page);
+    const dandisetId = await registerDandiset(page, faker.lorem.words(), faker.lorem.sentences());
+
+    await page.goto(`${clientUrl}/dandiset/${dandisetId}?overlay=meditor`);
+    await page.waitForLoadState("networkidle");
+
+    // Meditor dialog should be open
+    await expect(page.locator(".v-overlay--active .v-card")).toBeVisible();
+
+    // Close the dialog (press Escape)
+    await page.keyboard.press("Escape");
+    await page.waitForTimeout(500);
+
+    // overlay param should be gone
+    expect(new URL(page.url()).searchParams.has("overlay")).toBeFalsy();
+  });
+
+  test("navigating to ?overlay=meditor opens the meditor", async ({ page }) => {
+    await registerNewUser(page);
+    const dandisetId = await registerDandiset(page, faker.lorem.words(), faker.lorem.sentences());
+
+    await page.goto(`${clientUrl}/dandiset/${dandisetId}?overlay=meditor`);
+    await page.waitForLoadState("networkidle");
+
+    // Meditor dialog should be visible
+    await expect(page.locator(".v-overlay--active .v-card")).toBeVisible();
+  });
+});
diff --git a/web/src/components/DLP/HowToCiteTab.vue b/web/src/components/DLP/HowToCiteTab.vue
index 0a480aaf8..8e4e27bc0 100644
--- a/web/src/components/DLP/HowToCiteTab.vue
+++ b/web/src/components/DLP/HowToCiteTab.vue
@@ -231,7 +231,8 @@
 </template>
 
 <script setup lang="ts">
-import { computed, type PropType, ref } from 'vue';
+import { computed, type PropType, ref, watch } from 'vue';
+import { useRoute, useRouter } from 'vue-router';
 
 import { useDandisetStore } from '@/stores/dandiset';
 import type { DandisetMetadata } from '@/types';
@@ -273,8 +274,26 @@ const latestPublishedVersionLink = computed(() => {
 // Define citation format types
 type CitationFormat = 'apa' | 'mla' | 'chicago' | 'harvard' | 'vancouver' | 'ieee' | 'bibtex' | 'ris' | 'cff';
 
-// Citation format state
-const selectedCitationFormat = ref<CitationFormat>('apa'); // For the dropdown in Full Citation section
+// Sync citation format with ?format= URL query param.
+const route = useRoute();
+const router = useRouter();
+const validFormats: CitationFormat[] = ['apa', 'mla', 'chicago', 'harvard', 'vancouver', 'ieee', 'bibtex', 'ris', 'cff'];
+const initialFormat = validFormats.includes(route.query.format as CitationFormat)
+  ? route.query.format as CitationFormat
+  : 'apa';
+const selectedCitationFormat = ref<CitationFormat>(initialFormat);
+
+watch(selectedCitationFormat, (fmt) => {
+  const currentFmt = route.query.format as string | undefined;
+  if (fmt === currentFmt) return;
+  const query = { ...route.query };
+  if (fmt === 'apa') {
+    delete query.format;
+  } else {
+    query.format = fmt;
+  }
+  router.replace({ ...route, query });
+});
 
 // Generate CFF object from metadata
 const cffObject = computed(() => {
diff --git a/web/src/components/DandisetList.vue b/web/src/components/DandisetList.vue
index 34153af17..6a80da401 100644
--- a/web/src/components/DandisetList.vue
+++ b/web/src/components/DandisetList.vue
@@ -7,12 +7,7 @@
       v-for="(item, index) in dandisets"
       :key="item.dandiset.identifier"
       class="py-3"
-      :to="{
-        name: 'dandisetLanding',
-        params: { identifier: item.dandiset.identifier },
-        query: { ...$route.query, pos: getPos(index) },
-      }"
-      exact
+      @click="navigateToDandiset(item.dandiset.identifier, index)"
     >
       <v-list-item-title class="wrap-text text-h6 text-grey-darken-3 font-weight-medium">
         {{ item.name }}
@@ -80,7 +75,7 @@
 
 <script setup lang="ts">
 import { ref, onMounted, type PropType } from 'vue';
-import { useRoute } from 'vue-router';
+import { useRoute, useRouter } from 'vue-router';
 import moment from 'moment';
 import { filesize } from 'filesize';
 import StarButton from '@/components/StarButton.vue';
@@ -89,7 +84,7 @@ import { dandiRest } from '@/rest';
 import type { Version } from '@/types';
 import { DANDISETS_PER_PAGE } from '@/utils/constants';
 
-defineProps({
+const props = defineProps({
   dandisets: {
     type: Array as PropType<Version[]>,
     required: true,
@@ -97,6 +92,7 @@ defineProps({
 });
 
 const route = useRoute();
+const router = useRouter();
 const archiveName = ref<string>('');
 
 onMounted(async () => {
@@ -108,6 +104,32 @@ onMounted(async () => {
 function getPos(index: number) {
   return (Number(route.query.page || 1) - 1) * DANDISETS_PER_PAGE + (index + 1);
 }
+
+// Navigate to a dandiset, carrying listing context in history.state and pos in URL.
+// Cached identifiers from the current page allow instant prev/next without API calls.
+function navigateToDandiset(identifier: string, index: number) {
+  const cachedIds = props.dandisets.map((d) => d.dandiset.identifier);
+  const pageStart = (Number(route.query.page || 1) - 1) * DANDISETS_PER_PAGE;
+
+  const search = (route.query.search as string) || undefined;
+  router.push({
+    name: 'dandisetLanding',
+    params: { identifier },
+    query: { pos: String(getPos(index)), ...(search ? { search } : {}) },
+    state: {
+      listingContext: {
+        sortOption: Number(route.query.sortOption) || 0,
+        sortDir: Number(route.query.sortDir || -1),
+        search: (route.query.search as string) || null,
+        showDrafts: route.query.showDrafts !== 'false',
+        showEmpty: route.query.showEmpty === 'true',
+      },
+      // Cached identifiers with their absolute offset in the result set
+      cachedIds,
+      cachedOffset: pageStart, // 0-based offset of cachedIds[0] in the full result set
+    },
+  });
+}
 function formatDate(date: string) {
   return moment(date).format('LL');
 }
diff --git a/web/src/components/StarButton.vue b/web/src/components/StarButton.vue
index 0eaf18fd5..17b851de3 100644
--- a/web/src/components/StarButton.vue
+++ b/web/src/components/StarButton.vue
@@ -4,7 +4,7 @@
       variant="plain"
       icon
       :readonly="!loggedIn"
-      @click.prevent="toggleStar"
+      @click.stop.prevent="toggleStar"
     >
       <v-icon :color="isStarred ? 'amber darken-2' : undefined">
         {{ isStarred ? 'mdi-star' : 'mdi-star-outline' }}
diff --git a/web/src/router/index.ts b/web/src/router/index.ts
index d03e13844..07902fbdb 100644
--- a/web/src/router/index.ts
+++ b/web/src/router/index.ts
@@ -64,7 +64,34 @@ const routes: RouteRecordRaw[] = [
   },
 ];
 
-export default createRouter({
+// Listing-specific query params that must not appear on DLP URLs.
+// Listing-specific params to strip from DLP URLs.
+// Note: 'pos' and 'search' are intentionally NOT here — pos indicates position
+// in a result set, and search populates the search bar for context.
+const LISTING_PARAMS = ['page', 'sortOption', 'sortDir', 'showDrafts', 'showEmpty'];
+
+const router = createRouter({
   history: createWebHistory(),
   routes,
 });
+
+// Safety net: strip leaked listing params from DLP routes.
+router.beforeEach((to, _from, next) => {
+  if (to.name === 'dandisetLanding') {
+    const cleanQuery = { ...to.query };
+    let modified = false;
+    for (const param of LISTING_PARAMS) {
+      if (param in cleanQuery) {
+        delete cleanQuery[param];
+        modified = true;
+      }
+    }
+    if (modified) {
+      next({ ...to, query: cleanQuery });
+      return;
+    }
+  }
+  next();
+});
+
+export default router;
diff --git a/web/src/views/DandisetLandingView/DandisetLandingView.vue b/web/src/views/DandisetLandingView/DandisetLandingView.vue
index e05a01ee1..8846ea95b 100644
--- a/web/src/views/DandisetLandingView/DandisetLandingView.vue
+++ b/web/src/views/DandisetLandingView/DandisetLandingView.vue
@@ -7,6 +7,7 @@
     <v-toolbar class="px-4 bg-grey-darken-2 text-white">
       <DandisetSearchField />
       <v-pagination
+        v-if="hasListingContext"
         v-model="page"
         :length="pages"
         :total-visible="0"
@@ -118,7 +119,6 @@
 import {
   computed, watch, onMounted, ref,
 } from 'vue';
-import type { Ref } from 'vue';
 import { onBeforeRouteLeave, useRoute, useRouter } from 'vue-router';
 import type { RouteLocationRaw } from 'vue-router';
 import { useDisplay } from 'vuetify';
@@ -126,9 +126,9 @@ import { useDisplay } from 'vuetify';
 import DandisetSearchField from '@/components/DandisetSearchField.vue';
 import Meditor from '@/components/Meditor/Meditor.vue';
 import { useDandisetStore } from '@/stores/dandiset';
-import type { Dandiset, Version } from '@/types';
+import type { Version } from '@/types';
 import { draftVersion, sortingOptions } from '@/utils/constants';
-import { editorInterface } from '@/components/Meditor/state';
+import { editorInterface, open as meditorOpen } from '@/components/Meditor/state';
 import { dandiRest } from '@/rest';
 import DandisetMain from './DandisetMain.vue';
 import DandisetSidebar from './DandisetSidebar.vue';
@@ -164,6 +164,22 @@ const store = useDandisetStore();
 const display = useDisplay();
 
 const isSmDisplay = computed(() => display.smAndDown.value);
+
+// Sync meditor open/close state with ?overlay=meditor URL query param.
+if (route.query.overlay === 'meditor') {
+  meditorOpen.value = true;
+}
+watch(meditorOpen, (isOpen) => {
+  const hasParam = route.query.overlay === 'meditor';
+  if (isOpen && !hasParam) {
+    router.replace({ ...route, query: { ...route.query, overlay: 'meditor' } });
+  } else if (!isOpen && hasParam) {
+    const query = { ...route.query };
+    delete query.overlay;
+    router.replace({ ...route, query });
+  }
+});
+
 const currentDandiset = computed(() => store.dandiset);
 const loading = ref(false);
 
@@ -234,51 +250,92 @@ watch([() => props.identifier, () => props.version], async () => {
   loading.value = false;
 });
 
-const page = ref(Number(route.query.pos) || 1);
+// Listing pagination — uses history.state for search context (invisible in URL)
+// and ?pos= for position (visible, survives reload).  Cached identifiers from
+// the listing page allow instant prev/next without additional API calls.
+
+interface ListingCtx {
+  sortOption: number; sortDir: number; search: string | null;
+  showDrafts: boolean; showEmpty: boolean;
+}
+
+// Read listing context reactively from history.state on each route change.
+const listingState = computed(() => {
+  // Access route.fullPath to create a reactive dependency on route changes.
+  // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+  route.fullPath;
+  return {
+    ctx: window.history.state?.listingContext as ListingCtx | undefined,
+    cachedIds: (window.history.state?.cachedIds ?? []) as string[],
+    cachedOffset: (window.history.state?.cachedOffset ?? 0) as number,
+  };
+});
+
+const hasListingContext = computed(
+  () => Number(route.query.pos) > 0 && !!listingState.value.ctx,
+);
+const page = ref(Number(route.query.pos) || 0);
 const pages = ref(1);
-const nextDandiset: Ref<Partial<Dandiset>[]> = ref([]);
 
-async function fetchNextPage() {
-  const sortOption = Number(route.query.sortOption) || 0;
-  const sortDir = Number(route.query.sortDir || -1);
-  const sortField = sortingOptions[sortOption].djangoField;
-  const ordering = ((sortDir === -1) ? '-' : '') + sortField;
+// Keep `page` in sync when the route's ?pos= changes (e.g. after navigateToDandiset).
+watch(() => Number(route.query.pos) || 0, (newPos) => {
+  if (newPos !== page.value) {
+    page.value = newPos;
+  }
+});
+
+// Try to resolve an identifier from the cache (pos is 1-based).
+function cachedIdentifierAt(pos: number): string | null {
+  const { cachedIds, cachedOffset } = listingState.value;
+  const idx = pos - 1 - cachedOffset;
+  if (idx >= 0 && idx < cachedIds.length) {
+    return cachedIds[idx];
+  }
+  return null;
+}
+
+// Fallback: fetch one result at the given position from the listing API.
+async function fetchIdentifierAt(pos: number): Promise<string | null> {
+  const ctx = listingState.value.ctx;
+  if (!ctx) return null;
+  const sortField = sortingOptions[ctx.sortOption].djangoField;
+  const ordering = ((ctx.sortDir === -1) ? '-' : '') + sortField;
   const response = await dandiRest.dandisets({
-    page: page.value,
+    page: pos,
     page_size: 1,
     ordering,
-    search: route.query.search,
-    draft: route.query.showDrafts || true,
-    empty: route.query.showEmpty,
+    search: ctx.search,
+    draft: ctx.showDrafts,
+    empty: ctx.showEmpty,
   });
-
-  pages.value = (response.data?.count) ? response.data?.count : 1;
-  nextDandiset.value = response.data?.results.map((dandiset) => ({
-    ...(dandiset.most_recent_published_version || dandiset.draft_version),
-    contact_person: dandiset.contact_person,
-    identifier: dandiset.identifier,
-  }));
+  pages.value = response.data?.count ?? 1;
+  const results = response.data?.results;
+  return results?.[0]?.identifier ?? null;
 }
 
-function navigateToPage() {
-  if (nextDandiset.value) {
-    const { identifier } = nextDandiset.value[0];
-    if (identifier !== props.identifier) { // to avoid redundant navigation
-      router.push({
-        name: route.name || undefined,
-        params: { identifier },
-        query: {
-          ...route.query,
-        },
-      });
-    }
-  }
+function navigateToDandiset(identifier: string, pos: number) {
+  if (identifier === props.identifier) return;
+  const { ctx, cachedIds, cachedOffset } = listingState.value;
+  const search = (route.query.search as string) || undefined;
+  router.push({
+    name: route.name || undefined,
+    params: { identifier },
+    query: { pos: String(pos), ...(search ? { search } : {}) },
+    state: {
+      listingContext: ctx ? { ...ctx } : undefined,
+      cachedIds,
+      cachedOffset,
+    },
+  });
 }
 
-watch(page, async (newValue, oldValue) => {
-  if (oldValue !== newValue) {
-    await fetchNextPage();
-    navigateToPage();
+// When the user clicks prev/next, resolve the identifier and navigate.
+watch(page, async (newPos, oldPos) => {
+  if (oldPos === newPos || newPos < 1) return;
+
+  const identifier = cachedIdentifierAt(newPos) ?? await fetchIdentifierAt(newPos);
+  if (identifier) {
+    navigateToDandiset(identifier, newPos);
   }
 });
 
@@ -295,6 +352,10 @@ onMounted(async () => {
       e.returnValue = 'You have unsaved changes, are you sure you want to leave?';
     }
   });
-  await fetchNextPage(); // get the current page and total count
+  if (hasListingContext.value) {
+    // Fetch total count so the pagination component knows the length.
+    // If we have cache, we might still need the count from the API.
+    await fetchIdentifierAt(page.value);
+  }
 });
 </script>
diff --git a/web/src/views/DandisetLandingView/DandisetMain.vue b/web/src/views/DandisetLandingView/DandisetMain.vue
index e179b0ff2..6da07b773 100644
--- a/web/src/views/DandisetLandingView/DandisetMain.vue
+++ b/web/src/views/DandisetLandingView/DandisetMain.vue
@@ -267,6 +267,7 @@
 import {
   computed,
   ref,
+  watch,
   watchEffect,
   type ComputedRef,
 } from 'vue';
@@ -276,6 +277,7 @@ import { marked } from 'marked';
 import moment from 'moment';
 import DOMPurify from 'dompurify';
 import { useDisplay } from 'vuetify';
+import { useRoute, useRouter } from 'vue-router';
 
 import { useDandisetStore } from '@/stores/dandiset';
 import { getDoiMetadata } from '@/utils/doi';
@@ -292,11 +294,13 @@ const MAX_DESCRIPTION_LENGTH = 400;
 const tabs = [
   {
     name: 'Overview',
+    slug: 'overview',
     component: OverviewTab,
     icon: 'mdi-information-outline',
   },
   {
     name: 'How to Cite',
+    slug: 'how-to-cite',
     component: HowToCiteTab,
     icon: 'mdi-format-quote-close',
   },
@@ -358,7 +362,27 @@ const subjectMatter: ComputedRef<SubjectMatterOfTheDataset|undefined> = computed
   () => meta.value?.about,
 );
 
-const currentTab = ref(0);
+const route = useRoute();
+const router = useRouter();
+
+// Resolve the initial tab from the ?tab= query param (default to 0 / Overview).
+const initialTabIndex = tabs.findIndex((t) => t.slug === route.query.tab);
+const currentTab = ref(initialTabIndex >= 0 ? initialTabIndex : 0);
+
+// Sync tab selection → URL query param.
+watch(currentTab, (index) => {
+  const slug = tabs[index]?.slug;
+  const currentSlug = route.query.tab as string | undefined;
+  if (slug === currentSlug) return;
+  // Use the default tab (overview) without a query param to keep the base URL clean.
+  const query = { ...route.query };
+  if (index === 0) {
+    delete query.tab;
+  } else {
+    query.tab = slug;
+  }
+  router.replace({ ...route, query });
+});
 
 function formatDate(date: string): string {
   return moment(date).format('LL');