diff --git a/app/components/RunDisplay.vue b/app/components/RunDisplay.vue
index 5bdfac0..acf2bf6 100644
--- a/app/components/RunDisplay.vue
+++ b/app/components/RunDisplay.vue
@@ -6,7 +6,24 @@ defineProps<{
   error: string | null
   loading: boolean
   onClear: () => void
+  currentReportId?: string | null
 }>()
+
+const generateReportPermalink = (reportId: string) => {
+  const baseUrl = typeof window !== 'undefined' ? window.location.origin : ''
+  return `${baseUrl}/report/${reportId}`
+}
+
+const copyToClipboard = async (text: string) => {
+  if (typeof navigator !== 'undefined' && navigator.clipboard) {
+    try {
+      await navigator.clipboard.writeText(text)
+    }
+    catch (err) {
+      console.error('Failed to copy to clipboard:', err)
+    }
+  }
+}
 </script>
 
 <template>
@@ -35,6 +52,27 @@ defineProps<{
     </div>
 
     <div class="reset-container">
+      <div
+        v-if="currentReportId && runs.length > 0"
+        class="report-permalink"
+      >
+        <label>Share this report:</label>
+        <div class="permalink-container">
+          <input
+            :value="generateReportPermalink(currentReportId)"
+            readonly
+            class="permalink-input"
+          />
+          <button
+            class="copy-button"
+            title="Copy to clipboard"
+            @click="copyToClipboard(generateReportPermalink(currentReportId))"
+          >
+            📋
+          </button>
+        </div>
+      </div>
+
       <button
         v-if="runs.length > 0"
         @click="onClear()"
@@ -70,4 +108,54 @@ defineProps<{
   text-align: center;
   background-color: inherit;
 }
+
+.report-permalink {
+  margin-bottom: 1em;
+  padding: 1em;
+  background-color: var(--bg-200, #f8fafc);
+  border-radius: 0.5em;
+  border: 1px solid var(--border-200, #e2e8f0);
+}
+
+.report-permalink label {
+  display: block;
+  font-weight: 500;
+  margin-bottom: 0.5em;
+  color: var(--text-700, #374151);
+}
+
+.permalink-container {
+  display: flex;
+  gap: 0.5em;
+  align-items: stretch;
+  max-width: 100%;
+  margin: 0 auto;
+}
+
+.permalink-input {
+  flex: 1;
+  padding: 0.5em;
+  border: 1px solid var(--border-300, #d1d5db);
+  border-radius: 0.25em;
+  background-color: white;
+  font-family: monospace;
+  font-size: 0.875em;
+}
+
+.copy-button {
+  padding: 0.5em 1em;
+  background-color: white;
+  color: var(--blue-600, #2563eb);
+  border: 2px solid var(--blue-600, #2563eb);
+  border-radius: 0.25em;
+  cursor: pointer;
+  font-size: 0.875em;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+}
+
+.copy-button:hover {
+  background-color: var(--blue-50, #eff6ff);
+}
 </style>
diff --git a/app/composables/useRunManager.report.test.ts b/app/composables/useRunManager.report.test.ts
new file mode 100644
index 0000000..337d12c
--- /dev/null
+++ b/app/composables/useRunManager.report.test.ts
@@ -0,0 +1,125 @@
+/**
+ * @vitest-environment jsdom
+ */
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { useRunManager } from './useRunManager'
+import type { ApiRun } from '~/types/run'
+
+// Mock the getCacheHeaders function
+vi.mock('~/utils/getCacheHeaders', () => ({
+  default: vi.fn((headers: Record<string, string>) => headers),
+}))
+
+// Mock navigateTo composable
+vi.mock('#app/composables/router', () => ({
+  navigateTo: vi.fn(async () => {}),
+}))
+
+// Mock fetch and $fetch
+global.fetch = vi.fn()
+vi.stubGlobal('$fetch', vi.fn())
+
+describe('useRunManager - Report Functionality', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  it('tracks currentReportId state', () => {
+    const { currentReportId, setCurrentReportId } = useRunManager()
+
+    expect(currentReportId.value).toBe(null)
+
+    setCurrentReportId('test-report-123')
+    expect(currentReportId.value).toBe('test-report-123')
+
+    setCurrentReportId(null)
+    expect(currentReportId.value).toBe(null)
+  })
+
+  it('sends currentReportId in API requests when set', async () => {
+    const mockApiRun: ApiRun = {
+      runId: 'test-run',
+      url: 'https://example.com',
+      status: 200,
+      durationInMs: 100,
+      headers: { 'cache-control': 'max-age=3600' },
+      reportId: 'new-report-456',
+    }
+
+    const mockFetch = $fetch as unknown as ReturnType<typeof vi.fn>
+    mockFetch.mockResolvedValueOnce(mockApiRun)
+
+    const { handleRequestFormSubmit, setCurrentReportId, currentReportId } = useRunManager()
+
+    setCurrentReportId('existing-report-123')
+
+    await handleRequestFormSubmit({ url: 'https://example.com' })
+
+    expect(mockFetch).toHaveBeenCalledWith('/api/inspect-url', {
+      method: 'POST',
+      body: {
+        url: 'https://example.com',
+        currentReportId: 'existing-report-123',
+      },
+    })
+
+    // Should update to the new report ID returned from API
+    expect(currentReportId.value).toBe('new-report-456')
+  })
+
+  it('updates currentReportId when API returns new reportId', async () => {
+    const mockApiRun: ApiRun = {
+      runId: 'test-run',
+      url: 'https://example.com',
+      status: 200,
+      durationInMs: 100,
+      headers: { 'cache-control': 'max-age=3600' },
+      reportId: 'new-report-789',
+    }
+
+    const mockFetch = $fetch as unknown as ReturnType<typeof vi.fn>
+    mockFetch.mockResolvedValueOnce(mockApiRun)
+
+    const { handleRequestFormSubmit, currentReportId } = useRunManager()
+
+    expect(currentReportId.value).toBe(null)
+
+    await handleRequestFormSubmit({ url: 'https://example.com' })
+
+    expect(currentReportId.value).toBe('new-report-789')
+  })
+
+  it('clears currentReportId when clearing runs', async () => {
+    const { handleClickClear, setCurrentReportId, currentReportId } = useRunManager()
+
+    setCurrentReportId('test-report-123')
+    expect(currentReportId.value).toBe('test-report-123')
+
+    await handleClickClear()
+
+    expect(currentReportId.value).toBe(null)
+  })
+
+  it('handles API response without reportId', async () => {
+    const mockApiRun: ApiRun = {
+      runId: 'test-run',
+      url: 'https://example.com',
+      status: 200,
+      durationInMs: 100,
+      headers: { 'cache-control': 'max-age=3600' },
+      // No reportId in response
+    }
+
+    const mockFetch = $fetch as unknown as ReturnType<typeof vi.fn>
+    mockFetch.mockResolvedValueOnce(mockApiRun)
+
+    const { handleRequestFormSubmit, currentReportId, setCurrentReportId } = useRunManager()
+
+    setCurrentReportId('existing-report')
+
+    await handleRequestFormSubmit({ url: 'https://example.com' })
+
+    // Should keep existing reportId if API doesn't return one
+    expect(currentReportId.value).toBe('existing-report')
+  })
+})
diff --git a/app/composables/useRunManager.test.ts b/app/composables/useRunManager.test.ts
index c6d53ff..527d916 100644
--- a/app/composables/useRunManager.test.ts
+++ b/app/composables/useRunManager.test.ts
@@ -10,10 +10,14 @@ vi.mock('~/utils/getCacheHeaders', () => ({
   default: vi.fn((headers: Record<string, string>) => headers),
 }))
 
+// Mock navigateTo composable
+vi.mock('#app/composables/router', () => ({
+  navigateTo: vi.fn(async () => {}),
+}))
+
 // Mock fetch and $fetch
 global.fetch = vi.fn()
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-global.$fetch = vi.fn() as any
+vi.stubGlobal('$fetch', vi.fn())
 
 describe('useRunManager', () => {
   beforeEach(() => {
@@ -37,6 +41,7 @@ describe('useRunManager', () => {
       status: 200,
       durationInMs: 100,
       headers: { 'cache-control': 'max-age=3600' },
+      reportId: 'test-report',
     }
 
     const run = getRunFromApiRun(apiRun)
@@ -47,6 +52,7 @@ describe('useRunManager', () => {
       status: 200,
       durationInMs: 100,
       cacheHeaders: { 'cache-control': 'max-age=3600' },
+      reportId: 'test-report',
     })
   })
 
@@ -57,10 +63,10 @@ describe('useRunManager', () => {
       status: 200,
       durationInMs: 100,
       headers: { 'cache-control': 'max-age=3600' },
+      reportId: 'test-report',
     }
 
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const mockFetch = vi.mocked($fetch as any)
+    const mockFetch = $fetch as unknown as ReturnType<typeof vi.fn>
     mockFetch.mockResolvedValueOnce(mockApiRun)
 
     const { runs, error, loading, handleRequestFormSubmit } = useRunManager()
@@ -73,13 +79,15 @@ describe('useRunManager', () => {
     expect(runs.value[0]?.url).toBe('https://example.com')
     expect(mockFetch).toHaveBeenCalledWith('/api/inspect-url', {
       method: 'POST',
-      body: { url: 'https://example.com' },
+      body: {
+        url: 'https://example.com',
+        currentReportId: null,
+      },
     })
   })
 
   it('handles API request error', async () => {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const mockFetch = vi.mocked($fetch as any)
+    const mockFetch = $fetch as unknown as ReturnType<typeof vi.fn>
     mockFetch.mockRejectedValueOnce(new Error('HTTP 500'))
 
     const { runs, error, loading, handleRequestFormSubmit } = useRunManager()
diff --git a/app/composables/useRunManager.ts b/app/composables/useRunManager.ts
index 9c91c31..b1e5abd 100644
--- a/app/composables/useRunManager.ts
+++ b/app/composables/useRunManager.ts
@@ -4,6 +4,7 @@ export const useRunManager = () => {
   const runs = ref<Run[]>([])
   const error = ref<string | null>(null)
   const loading = ref<boolean>(false)
+  const currentReportId = ref<string | null>(null)
 
   const getRunFromApiRun = (apiRun: ApiRun): Run => {
     const { headers, ...run } = apiRun
@@ -19,10 +20,21 @@ export const useRunManager = () => {
     try {
       const responseBody: ApiRun = await $fetch<ApiRun>('/api/inspect-url', {
         method: 'POST',
-        body: { url },
+        body: {
+          url,
+          currentReportId: currentReportId.value,
+        },
       })
 
       runs.value.push(getRunFromApiRun(responseBody))
+
+      // Update current report ID with the new one returned from the API
+      if (responseBody.reportId) {
+        currentReportId.value = responseBody.reportId
+        // Navigate to the report URL to make it the source of truth
+        await navigateTo(`/report/${responseBody.reportId}`)
+      }
+
       error.value = null
     }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -38,8 +50,11 @@ export const useRunManager = () => {
     }
   }
 
-  const handleClickClear = (): void => {
+  const handleClickClear = async (): Promise<void> => {
     runs.value = []
+    currentReportId.value = null
+    // Navigate back to home
+    await navigateTo('/')
   }
 
   const addRun = (run: Run): void => {
@@ -54,11 +69,16 @@ export const useRunManager = () => {
     error.value = newError
   }
 
+  const setCurrentReportId = (reportId: string | null): void => {
+    currentReportId.value = reportId
+  }
+
   return {
     // State
     runs: readonly(runs),
     error: readonly(error),
     loading: readonly(loading),
+    currentReportId: readonly(currentReportId),
 
     // Methods
     handleRequestFormSubmit,
@@ -66,6 +86,7 @@ export const useRunManager = () => {
     addRun,
     setRuns,
     setError,
+    setCurrentReportId,
     getRunFromApiRun,
   }
 }
diff --git a/app/pages/index.vue b/app/pages/index.vue
index 1f6934c..88bdbd6 100644
--- a/app/pages/index.vue
+++ b/app/pages/index.vue
@@ -1,5 +1,5 @@
 <script setup lang="ts">
-const { runs, error, loading, handleRequestFormSubmit, handleClickClear } = useRunManager()
+const { runs, error, loading, handleRequestFormSubmit, handleClickClear, currentReportId } = useRunManager()
 </script>
 
 <template>
@@ -14,6 +14,7 @@ const { runs, error, loading, handleRequestFormSubmit, handleClickClear } = useR
       :error="error"
       :loading="loading"
       :on-clear="handleClickClear"
+      :current-report-id="currentReportId"
     />
   </main>
 </template>
diff --git a/app/pages/report/[reportId].vue b/app/pages/report/[reportId].vue
new file mode 100644
index 0000000..3403058
--- /dev/null
+++ b/app/pages/report/[reportId].vue
@@ -0,0 +1,47 @@
+<script setup lang="ts">
+import type { ApiRun } from '~/types/run'
+
+const { runs, error, loading, handleRequestFormSubmit, handleClickClear, getRunFromApiRun, setRuns, setError, currentReportId, setCurrentReportId } = useRunManager()
+
+const route = useRoute()
+
+const { data: reportData, pending: _pending, error: preloadedReportError } = await useAsyncData('preloadedReport', async () => {
+  const { reportId } = route.params
+  if (typeof reportId === 'string') {
+    const responseBody = await $fetch(`/api/reports/${reportId}`)
+    return responseBody
+  }
+  return null
+})
+
+if (preloadedReportError.value) {
+  setError(preloadedReportError.value.toString())
+}
+else if (reportData.value) {
+  // Set current report ID so new runs get added to this report
+  setCurrentReportId(reportData.value.reportId)
+  // Convert API runs to frontend runs
+  const frontendRuns = reportData.value.runs.map((apiRun: ApiRun) => getRunFromApiRun(apiRun))
+  setRuns(frontendRuns)
+}
+</script>
+
+<template>
+  <main>
+    <RequestForm
+      :loading="loading"
+      @submit="handleRequestFormSubmit"
+    />
+
+    <RunDisplay
+      :runs="runs"
+      :error="error"
+      :loading="loading"
+      :on-clear="handleClickClear"
+      :current-report-id="currentReportId"
+    />
+  </main>
+</template>
+
+<style scoped>
+</style>
diff --git a/app/pages/run/[runId].vue b/app/pages/run/[runId].vue
index c3e6c9c..5ed1156 100644
--- a/app/pages/run/[runId].vue
+++ b/app/pages/run/[runId].vue
@@ -1,5 +1,5 @@
 <script setup lang="ts">
-const { runs, error, loading, handleRequestFormSubmit, handleClickClear, getRunFromApiRun, setRuns, setError } = useRunManager()
+const { runs, error, loading, handleRequestFormSubmit, handleClickClear, getRunFromApiRun, setRuns, setError, setCurrentReportId, currentReportId } = useRunManager()
 
 const route = useRoute()
 
@@ -17,6 +17,8 @@ if (preloadedRunsError.value) {
 }
 if (initialRuns.value) {
   setRuns(initialRuns.value)
+  // When viewing a single run, clear any existing report ID so new runs start fresh
+  setCurrentReportId(null)
 }
 
 // Get the URL from the loaded run - we know it exists since we successfully loaded the run
@@ -48,6 +50,7 @@ const runUrl = computed(() => {
       :error="error"
       :loading="loading"
       :on-clear="handleClickClear"
+      :current-report-id="currentReportId"
     />
   </main>
 </template>
diff --git a/app/types/report.ts b/app/types/report.ts
new file mode 100644
index 0000000..8099343
--- /dev/null
+++ b/app/types/report.ts
@@ -0,0 +1,7 @@
+export interface Report {
+  reportId: string
+  runIds: string[]
+  createdAt: number
+}
+
+export type ApiReport = Report
diff --git a/app/types/run.ts b/app/types/run.ts
index eec2791..6eee7d8 100644
--- a/app/types/run.ts
+++ b/app/types/run.ts
@@ -4,6 +4,9 @@ export interface Run {
   status: number
   cacheHeaders: Record<string, string>
   durationInMs: number
+  reportId?: string
 }
 
-export type ApiRun = Omit<Run, 'cacheHeaders'> & { headers: Record<string, string> }
+export type ApiRun = Omit<Run, 'cacheHeaders'> & {
+  headers: Record<string, string>
+}
diff --git a/server/api/inspect-url.post.ts b/server/api/inspect-url.post.ts
index 26820d3..0545051 100644
--- a/server/api/inspect-url.post.ts
+++ b/server/api/inspect-url.post.ts
@@ -1,5 +1,5 @@
 import { createHash } from 'crypto'
-import { saveRun } from '~server/db'
+import { saveRun, saveReport, getReport } from '~server/db'
 
 const generateRunId = (url: string, timestamp: number): string =>
   createHash('sha256')
@@ -7,8 +7,14 @@ const generateRunId = (url: string, timestamp: number): string =>
     .digest('hex')
     .slice(0, 8)
 
+const generateReportId = (runIds: string[], timestamp: number): string =>
+  createHash('sha256')
+    .update(`${runIds.join(',')}-${timestamp}`)
+    .digest('hex')
+    .slice(0, 8)
+
 export default defineEventHandler(async (event) => {
-  const { url } = await readBody(event)
+  const { url, currentReportId } = await readBody(event)
 
   if (!url) {
     throw createError({
@@ -58,5 +64,38 @@ export default defineEventHandler(async (event) => {
 
   await saveRun(run)
 
-  return run
+  // Handle report creation/updating
+  let newReportId: string
+  const timestamp = Date.now()
+
+  if (currentReportId) {
+    // Get existing report and create a new one with the additional run
+    const existingReport = await getReport(currentReportId)
+    const newRunIds = [...existingReport.runIds, run.runId]
+    newReportId = generateReportId(newRunIds, timestamp)
+
+    const newReport = {
+      reportId: newReportId,
+      runIds: newRunIds,
+      createdAt: timestamp,
+    }
+
+    await saveReport(newReport)
+  }
+  else {
+    // Create a new report with just this run
+    newReportId = generateReportId([run.runId], timestamp)
+    const newReport = {
+      reportId: newReportId,
+      runIds: [run.runId],
+      createdAt: timestamp,
+    }
+
+    await saveReport(newReport)
+  }
+
+  return {
+    ...run,
+    reportId: newReportId,
+  }
 })
diff --git a/server/api/reports/[reportId].ts b/server/api/reports/[reportId].ts
new file mode 100644
index 0000000..40e1919
--- /dev/null
+++ b/server/api/reports/[reportId].ts
@@ -0,0 +1,36 @@
+import { getReport, getRun } from '~server/db'
+
+export default defineEventHandler(async (event) => {
+  const reportId = getRouterParam(event, 'reportId')
+
+  if (!reportId) {
+    throw createError({
+      statusCode: 400,
+      message: 'Missing reportId parameter',
+    })
+  }
+
+  try {
+    const report = await getReport(reportId)
+
+    // Fetch all runs for this report
+    const runs = await Promise.all(
+      report.runIds.map(runId => getRun(runId)),
+    )
+
+    // Set cache headers similar to /run/ endpoints
+    setHeader(event, 'Cache-Control', 'public, max-age=31536000, immutable')
+
+    return {
+      reportId: report.reportId,
+      createdAt: report.createdAt,
+      runs,
+    }
+  }
+  catch (error) {
+    throw createError({
+      statusCode: 500,
+      message: error instanceof Error ? error.message : 'Failed to fetch report',
+    })
+  }
+})
diff --git a/server/db.ts b/server/db.ts
index 8a8be04..2f9c31b 100644
--- a/server/db.ts
+++ b/server/db.ts
@@ -8,7 +8,14 @@ interface Run {
   durationInMs: number
 }
 
+interface Report {
+  reportId: string
+  runIds: string[]
+  createdAt: number
+}
+
 const runs = getStore({ name: 'runs' })
+const reports = getStore({ name: 'reports' })
 
 export const saveRun = async (run: Run): Promise<void> => {
   // Validate the run data before saving
@@ -36,3 +43,20 @@ export const getRun = async (runId: string): Promise<Run> => {
 
   return run
 }
+
+export const saveReport = async (report: Report): Promise<void> => {
+  await reports.setJSON(report.reportId, report)
+}
+
+export const getReport = async (reportId: string): Promise<Report> => {
+  const report: Report | null = await reports.get(reportId, { type: 'json' })
+
+  if (!report) {
+    throw createError({
+      statusCode: 404,
+      message: 'Report not found',
+    })
+  }
+
+  return report
+}