diff --git a/src/components/Features/SearchContent.vue b/src/components/Features/SearchContent.vue
index 71a3b5c..79bd959 100644
--- a/src/components/Features/SearchContent.vue
+++ b/src/components/Features/SearchContent.vue
@@ -1,7 +1,7 @@
 <template>
   <UtilitySection
     title="Search Content"
-    description="Search through pages, blog posts, or collections for content matching your search term. Results will highlight exactly where matches were found."
+    :description="`Search through pages, blog posts, or collections for content ${negateSearch ? 'NOT' : ''} matching your search term. Results will highlight exactly where matches were ${negateSearch ? 'NOT' : ''} found.`"
   >
     <!-- Search Scopes Selection -->
     <fieldset class="search-content__scopes-selection">
@@ -73,6 +73,20 @@
       </div>
     </fieldset>
 
+    <!-- Negation Option -->
+    <fieldset class="search-content__negation-section">
+      <legend class="search-content__negation-label">Search Mode</legend>
+      <label class="search-content__checkbox-option">
+        <input
+          type="checkbox"
+          v-model="negateSearch"
+          :disabled="hasResults"
+          aria-label="Negate search to find items NOT containing the search term"
+        />
+        <span>Show items NOT containing search term</span>
+      </label>
+    </fieldset>
+
     <!-- Search Term -->
     <TextInput
       id="search-content-search-term"
@@ -172,6 +186,7 @@ const includeBlog = computed({
   },
 })
 const searchTerm = ref('')
+const negateSearch = ref(false)
 const showMissingSearchTermError = ref(false)
 const isLoading = ref(false)
 const statusMessage = ref('')
@@ -277,6 +292,7 @@ async function executeSearch(): Promise<void> {
       store.selectedScopes.pageTypes,
       store.selectedScopes.collectionKeys,
       includeBlog.value,
+      negateSearch.value,
     )
 
     if (!searchResponse.success) {
@@ -288,15 +304,17 @@ async function executeSearch(): Promise<void> {
 
     totalItems.value = searchResponse.totalItems!
 
+    const modeText = negateSearch.value ? 'NOT containing' : 'containing'
+
     if (searchResponse.results.length === 0) {
       setStatus(
-        `No matches found for "${searchTermValue}" in ${searchResponse.totalItems} selected items`,
+        `No items ${modeText} "${searchTermValue}" found in ${searchResponse.totalItems} selected items`,
         'info',
         false,
       )
     } else {
       setStatus(
-        `Found ${searchResponse.results.length} items with matches out of ${searchResponse.totalItems} total selected items`,
+        `Found ${searchResponse.results.length} items ${modeText} "${searchTermValue}" out of ${searchResponse.totalItems} total selected items`,
         'success',
         false,
       )
@@ -339,6 +357,20 @@ function getResultMatchCount(
     font-size: 0.9375rem;
   }
 
+  &__negation-section {
+    margin: 1.5rem 0;
+    padding: 0;
+    border: 0;
+  }
+
+  &__negation-label {
+    display: block;
+    font-weight: 500;
+    margin-bottom: 0.75rem;
+    color: var(--text-primary);
+    font-size: 0.9375rem;
+  }
+
   &__checkbox-option {
     display: flex;
     align-items: center;
diff --git a/src/components/WhatsNew.vue b/src/components/WhatsNew.vue
index cb51531..367c750 100644
--- a/src/components/WhatsNew.vue
+++ b/src/components/WhatsNew.vue
@@ -40,6 +40,14 @@ interface Feature {
 const showModal = ref<boolean>(false)
 
 const features: Feature[] = [
+  {
+    id: 'search-content-negate',
+    type: 'improvement',
+    title: 'Ability to negate search in Search Content to find items NOT containing search term',
+    description:
+      'You can now negate your search in the Search Content utility to find items that do NOT contain your search term. This is useful for finding items that may be missing a term you expected to be there, or for excluding common terms to find more specific results. Simply check the "Show items NOT containing search term" checkbox.',
+    utcDatetimeAdded: new Date('2026-02-08T20:30:00Z'),
+  },
   {
     id: 'search-content-multi-scope',
     type: 'improvement',
@@ -47,7 +55,7 @@ const features: Feature[] = [
       'Define and store your known page types & collections keys, and search across them simultaneously',
     description:
       'You can now use the API Configuration UI to store your known page types and collection keys. These will be remembered on your device. Use these to use the new checkbox-UI in the Search Content utility to search across all your content simultaneously, instead of having to search each page type and collection separately.',
-    utcDatetimeAdded: new Date('2026-02-08T20:30:00Z'),
+    utcDatetimeAdded: new Date('2026-02-08T20:15:00Z'),
   },
   {
     id: 'search-content-alt-text',
@@ -79,7 +87,7 @@ const features: Feature[] = [
     title: 'Normalise &nbsp; and spaces',
     description:
       'Searching for a "<code> </code>" (space) now also returns results with non-breaking spaces (<code>&amp;nbsp;</code>), and vice versa.',
-    utcDatetimeAdded: new Date('2026-01-14T19:30:00Z'),
+    utcDatetimeAdded: new Date('2026-01-24T19:30:00Z'),
   },
   {
     id: 'search-content',
diff --git a/src/features/searchContent.spec.ts b/src/features/searchContent.spec.ts
index aa726f7..b2fa738 100644
--- a/src/features/searchContent.spec.ts
+++ b/src/features/searchContent.spec.ts
@@ -248,4 +248,192 @@ describe('searchContent', () => {
       expect(result.results).toHaveLength(1)
     })
   })
+
+  describe('Negation mode', () => {
+    it('should return items NOT containing search term when negate is true', async () => {
+      mockGetAllPages.mockImplementation(async () => [
+        {
+          id: '1',
+          slug: 'about',
+          name: 'About Us',
+          page_type: 'landing_page',
+          published: '2023-01-01',
+        },
+        {
+          id: '2',
+          slug: 'contact',
+          name: 'Contact Page',
+          page_type: 'landing_page',
+          published: '2023-01-02',
+        },
+        {
+          id: '3',
+          slug: 'services',
+          name: 'TestServices',
+          page_type: 'landing_page',
+          published: '2023-01-03',
+        },
+      ])
+      mockGetAllPosts.mockImplementation(async () => [])
+      mockGetAllCollections.mockImplementation(async () => [])
+
+      const result = await searchContent(
+        'Test',
+        'test-token',
+        false,
+        ['landing_page'],
+        [],
+        false,
+        true,
+      )
+
+      expect(result.success).toBe(true)
+      expect(result.results).toHaveLength(2)
+      expect(result.results.map((r) => r.slug)).toEqual(['about', 'contact'])
+    })
+
+    it('should return empty matches array for negated results', async () => {
+      mockGetAllPages.mockImplementation(async () => [
+        {
+          id: '1',
+          slug: 'about',
+          name: 'About Us',
+          page_type: 'landing_page',
+          published: '2023-01-01',
+        },
+      ])
+      mockGetAllPosts.mockImplementation(async () => [])
+      mockGetAllCollections.mockImplementation(async () => [])
+
+      const result = await searchContent(
+        'Test',
+        'test-token',
+        false,
+        ['landing_page'],
+        [],
+        false,
+        true,
+      )
+
+      expect(result.success).toBe(true)
+      expect(result.results).toHaveLength(1)
+      expect(result.results[0]!.matches).toHaveLength(0)
+    })
+
+    it('should work with multiple scopes in negate mode', async () => {
+      mockGetAllPages.mockImplementation(async () => [
+        {
+          id: '1',
+          slug: 'test-page',
+          name: 'TestPage',
+          page_type: 'landing_page',
+          published: '2023-01-01',
+        },
+        {
+          id: '2',
+          slug: 'about',
+          name: 'About',
+          page_type: 'landing_page',
+          published: '2023-01-02',
+        },
+      ])
+      mockGetAllPosts.mockImplementation(async () => [
+        {
+          id: '1',
+          slug: 'post-1',
+          title: 'Regular Post',
+          published: '2023-01-01',
+        },
+        {
+          id: '2',
+          slug: 'test-blog',
+          title: 'Test Blog Post',
+          published: '2023-01-02',
+        },
+      ])
+      mockGetAllCollections.mockImplementation(async () => [])
+
+      const result = await searchContent(
+        'Test',
+        'test-token',
+        false,
+        ['landing_page'],
+        [],
+        true,
+        true,
+      )
+
+      expect(result.success).toBe(true)
+      expect(result.results).toHaveLength(2)
+      expect(result.results.map((r) => r.slug).sort()).toEqual(['about', 'post-1'])
+    })
+
+    it('should return all items when negating and no items contain search term', async () => {
+      mockGetAllPages.mockImplementation(async () => [
+        {
+          id: '1',
+          slug: 'page-1',
+          name: 'Page One',
+          page_type: 'landing_page',
+          published: '2023-01-01',
+        },
+        {
+          id: '2',
+          slug: 'page-2',
+          name: 'Page Two',
+          page_type: 'landing_page',
+          published: '2023-01-02',
+        },
+      ])
+      mockGetAllPosts.mockImplementation(async () => [])
+      mockGetAllCollections.mockImplementation(async () => [])
+
+      const result = await searchContent(
+        'NonExistent',
+        'test-token',
+        false,
+        ['landing_page'],
+        [],
+        false,
+        true,
+      )
+
+      expect(result.success).toBe(true)
+      expect(result.results).toHaveLength(2)
+    })
+
+    it('should return no items when negating and all items contain search term', async () => {
+      mockGetAllPages.mockImplementation(async () => [
+        {
+          id: '1',
+          slug: 'test-1',
+          name: 'Test Page One',
+          page_type: 'landing_page',
+          published: '2023-01-01',
+        },
+        {
+          id: '2',
+          slug: 'test-2',
+          name: 'Test Page Two',
+          page_type: 'landing_page',
+          published: '2023-01-02',
+        },
+      ])
+      mockGetAllPosts.mockImplementation(async () => [])
+      mockGetAllCollections.mockImplementation(async () => [])
+
+      const result = await searchContent(
+        'Test',
+        'test-token',
+        false,
+        ['landing_page'],
+        [],
+        false,
+        true,
+      )
+
+      expect(result.success).toBe(true)
+      expect(result.results).toHaveLength(0)
+    })
+  })
 })
diff --git a/src/features/searchContent.ts b/src/features/searchContent.ts
index efb3933..e91f379 100644
--- a/src/features/searchContent.ts
+++ b/src/features/searchContent.ts
@@ -134,6 +134,7 @@ export async function searchContent(
   selectedPageTypes: string[],
   selectedCollectionKeys: string[],
   includeBlog: boolean,
+  negate: boolean = false,
 ): Promise<SearchResponse> {
   // Validate and normalize search input
   const trimmedSearch = searchString.trim()
@@ -202,31 +203,14 @@ export async function searchContent(
 
     for (const { data: itemData, sourceType } of itemsWithSource) {
       const matchMap = searchObject(itemData, searchLower)
+      const hasMatches = matchMap.size > 0
 
-      if (matchMap.size > 0) {
+      // When negating: include items WITHOUT matches. When not negating: include items WITH matches
+      if (hasMatches === !negate) {
         const item = itemData as Record<string, unknown>
 
-        // Convert map to array of matches
-        const matches = Array.from(matchMap.values()).map((acc) => {
-          // For multiple occurrences, show count in path and use first snippet
-          if (acc.count > 1) {
-            return {
-              path: `${acc.path} (${acc.count} occurrences)`,
-              value: acc.snippets[0] || '',
-              count: acc.count,
-            }
-          }
-          // For single occurrence, return as-is
-          return {
-            path: acc.path,
-            value: acc.snippets[0] || '',
-            count: acc.count,
-          }
-        })
-
-        const validMatches = matches.filter((m) => m.value && m.value.trim().length > 0)
-
-        if (validMatches.length > 0) {
+        // When negating, we don't show any matches since we're looking for items that DON'T contain the term
+        if (negate) {
           searchResults.push({
             title:
               (item.name as string) ||
@@ -235,8 +219,41 @@ export async function searchContent(
               'Untitled',
             slug: (item.slug as string) || 'N/A',
             sourceType: sourceType,
-            matches: validMatches,
+            matches: [],
           })
+        } else {
+          // Convert map to array of matches
+          const matches = Array.from(matchMap.values()).map((acc) => {
+            // For multiple occurrences, show count in path and use first snippet
+            if (acc.count > 1) {
+              return {
+                path: `${acc.path} (${acc.count} occurrences)`,
+                value: acc.snippets[0] || '',
+                count: acc.count,
+              }
+            }
+            // For single occurrence, return as-is
+            return {
+              path: acc.path,
+              value: acc.snippets[0] || '',
+              count: acc.count,
+            }
+          })
+
+          const validMatches = matches.filter((m) => m.value && m.value.trim().length > 0)
+
+          if (validMatches.length > 0) {
+            searchResults.push({
+              title:
+                (item.name as string) ||
+                (item.title as string) ||
+                (item.slug as string) ||
+                'Untitled',
+              slug: (item.slug as string) || 'N/A',
+              sourceType: sourceType,
+              matches: validMatches,
+            })
+          }
         }
       }
     }