diff --git a/src/paperless_ai/matching.py b/src/paperless_ai/matching.py
index c47c95001..47d59243b 100644
--- a/src/paperless_ai/matching.py
+++ b/src/paperless_ai/matching.py
@@ -8,45 +8,48 @@ from documents.models import Correspondent
 from documents.models import DocumentType
 from documents.models import StoragePath
 from documents.models import Tag
-from documents.permissions import get_objects_for_user_owner_aware
+from documents.permissions import permitted_object_ids
 
 MATCH_THRESHOLD = 0.8
 
 logger = logging.getLogger("paperless_ai.matching")
 
+# Note: with a None user, e.g. a workflow acting on an unowned document,
+# permitted_object_ids returns unowned objects only, so it won't return
+# someone's private tag.
 
-def match_tags_by_name(names: list[str], user: User) -> list[Tag]:
-    queryset = get_objects_for_user_owner_aware(
-        user,
-        ["view_tag"],
-        Tag,
+
+def match_tags_by_name(names: list[str], user: User | None) -> list[Tag]:
+    queryset = Tag.objects.filter(id__in=permitted_object_ids(user, Tag, "view_tag"))
+    return _match_names_to_queryset(names, queryset, "name")
+
+
+def match_correspondents_by_name(
+    names: list[str],
+    user: User | None,
+) -> list[Correspondent]:
+    queryset = Correspondent.objects.filter(
+        id__in=permitted_object_ids(user, Correspondent, "view_correspondent"),
     )
     return _match_names_to_queryset(names, queryset, "name")
 
 
-def match_correspondents_by_name(names: list[str], user: User) -> list[Correspondent]:
-    queryset = get_objects_for_user_owner_aware(
-        user,
-        ["view_correspondent"],
-        Correspondent,
+def match_document_types_by_name(
+    names: list[str],
+    user: User | None,
+) -> list[DocumentType]:
+    queryset = DocumentType.objects.filter(
+        id__in=permitted_object_ids(user, DocumentType, "view_documenttype"),
     )
     return _match_names_to_queryset(names, queryset, "name")
 
 
-def match_document_types_by_name(names: list[str], user: User) -> list[DocumentType]:
-    queryset = get_objects_for_user_owner_aware(
-        user,
-        ["view_documenttype"],
-        DocumentType,
-    )
-    return _match_names_to_queryset(names, queryset, "name")
-
-
-def match_storage_paths_by_name(names: list[str], user: User) -> list[StoragePath]:
-    queryset = get_objects_for_user_owner_aware(
-        user,
-        ["view_storagepath"],
-        StoragePath,
+def match_storage_paths_by_name(
+    names: list[str],
+    user: User | None,
+) -> list[StoragePath]:
+    queryset = StoragePath.objects.filter(
+        id__in=permitted_object_ids(user, StoragePath, "view_storagepath"),
     )
     return _match_names_to_queryset(names, queryset, "name")
 
diff --git a/src/paperless_ai/tests/test_matching.py b/src/paperless_ai/tests/test_matching.py
index 5cf23f2b8..57ae47d83 100644
--- a/src/paperless_ai/tests/test_matching.py
+++ b/src/paperless_ai/tests/test_matching.py
@@ -1,5 +1,3 @@
-from unittest.mock import patch
-
 import pytest
 from django.test import TestCase
 
@@ -32,33 +30,25 @@ class TestAIMatching(TestCase):
         self.storage_path1 = StoragePath.objects.create(name="Test Storage Path 1")
         self.storage_path2 = StoragePath.objects.create(name="Test Storage Path 2")
 
-    @patch("paperless_ai.matching.get_objects_for_user_owner_aware")
-    def test_match_tags_by_name(self, mock_get_objects) -> None:
-        mock_get_objects.return_value = Tag.objects.all()
+    def test_match_tags_by_name(self) -> None:
         names = ["Test Tag 1", "Nonexistent Tag"]
         result = match_tags_by_name(names, user=None)
         self.assertEqual(len(result), 1)
         self.assertEqual(result[0].name, "Test Tag 1")
 
-    @patch("paperless_ai.matching.get_objects_for_user_owner_aware")
-    def test_match_correspondents_by_name(self, mock_get_objects) -> None:
-        mock_get_objects.return_value = Correspondent.objects.all()
+    def test_match_correspondents_by_name(self) -> None:
         names = ["Test Correspondent 1", "Nonexistent Correspondent"]
         result = match_correspondents_by_name(names, user=None)
         self.assertEqual(len(result), 1)
         self.assertEqual(result[0].name, "Test Correspondent 1")
 
-    @patch("paperless_ai.matching.get_objects_for_user_owner_aware")
-    def test_match_document_types_by_name(self, mock_get_objects) -> None:
-        mock_get_objects.return_value = DocumentType.objects.all()
+    def test_match_document_types_by_name(self) -> None:
         names = ["Test Document Type 1", "Nonexistent Document Type"]
         result = match_document_types_by_name(names, user=None)
         self.assertEqual(len(result), 1)
         self.assertEqual(result[0].name, "Test Document Type 1")
 
-    @patch("paperless_ai.matching.get_objects_for_user_owner_aware")
-    def test_match_storage_paths_by_name(self, mock_get_objects) -> None:
-        mock_get_objects.return_value = StoragePath.objects.all()
+    def test_match_storage_paths_by_name(self) -> None:
         names = ["Test Storage Path 1", "Nonexistent Storage Path"]
         result = match_storage_paths_by_name(names, user=None)
         self.assertEqual(len(result), 1)
@@ -70,16 +60,12 @@ class TestAIMatching(TestCase):
         unmatched_names = extract_unmatched_names(llm_names, matched_objects)
         self.assertEqual(unmatched_names, ["Nonexistent Tag"])
 
-    @patch("paperless_ai.matching.get_objects_for_user_owner_aware")
-    def test_match_tags_by_name_with_empty_names(self, mock_get_objects) -> None:
-        mock_get_objects.return_value = Tag.objects.all()
+    def test_match_tags_by_name_with_empty_names(self) -> None:
         names = [None, "", "   "]
         result = match_tags_by_name(names, user=None)
         self.assertEqual(result, [])
 
-    @patch("paperless_ai.matching.get_objects_for_user_owner_aware")
-    def test_match_tags_with_fuzzy_matching(self, mock_get_objects) -> None:
-        mock_get_objects.return_value = Tag.objects.all()
+    def test_match_tags_with_fuzzy_matching(self) -> None:
         names = ["Test Taag 1", "Teest Tag 2"]
         result = match_tags_by_name(names, user=None)
         self.assertEqual(len(result), 2)