diff --git a/lbry/schema/result.py b/lbry/schema/result.py
index 3469a9c4c..d0889898e 100644
--- a/lbry/schema/result.py
+++ b/lbry/schema/result.py
@@ -38,7 +38,9 @@ class Censor:
         for claim_hash, lookup in (
                 (row['claim_hash'], self.streams),
                 (row['claim_hash'], self.channels),
-                (row['channel_hash'], self.channels)):
+                (row['channel_hash'], self.channels),
+                (row['reposted_claim_hash'], self.streams),
+                (row['reposted_claim_hash'], self.channels)):
             censoring_channel_hash = lookup.get(claim_hash)
             if censoring_channel_hash:
                 was_censored = True
diff --git a/lbry/testcase.py b/lbry/testcase.py
index dc3c5ff2e..4878f36fb 100644
--- a/lbry/testcase.py
+++ b/lbry/testcase.py
@@ -571,4 +571,4 @@ class CommandTestCase(IntegrationTestCase):
         return tx['outputs'][0]['claim_id']
 
     def assertItemCount(self, result, count):  # pylint: disable=invalid-name
-        self.assertEqual(result['total_items'], count)
+        self.assertEqual(count, result['total_items'])
diff --git a/lbry/wallet/server/db/reader.py b/lbry/wallet/server/db/reader.py
index 98bdcb933..b60990001 100644
--- a/lbry/wallet/server/db/reader.py
+++ b/lbry/wallet/server/db/reader.py
@@ -317,7 +317,13 @@ def claims_query(cols, for_count=False, **constraints) -> Tuple[str, Dict]:
         constraints['claim.txo_hash'] = tx_hash + struct.pack('<I', nout)
 
     if 'claim_type' in constraints:
-        constraints['claim.claim_type'] = CLAIM_TYPES[constraints.pop('claim_type')]
+        claim_types = constraints.pop('claim_type')
+        if isinstance(claim_types, str):
+            claim_types = [claim_types]
+        if claim_types:
+            constraints['claim.claim_type__in'] = {
+                CLAIM_TYPES[claim_type] for claim_type in claim_types
+            }
     if 'stream_types' in constraints:
         stream_types = constraints.pop('stream_types')
         if stream_types:
@@ -484,6 +490,14 @@ def resolve_url(raw_url):
     return channel
 
 
+CLAIM_HASH_OR_REPOST_HASH_SQL = f"""
+CASE WHEN claim.claim_type = {CLAIM_TYPES['repost']}
+    THEN claim.reposted_claim_hash
+    ELSE claim.claim_hash
+END
+"""
+
+
 def _apply_constraints_for_array_attributes(constraints, attr, cleaner, for_count=False):
     any_items = set(cleaner(constraints.pop(f'any_{attr}s', []))[:ATTRIBUTE_ARRAY_MAX_LENGTH])
     all_items = set(cleaner(constraints.pop(f'all_{attr}s', []))[:ATTRIBUTE_ARRAY_MAX_LENGTH])
@@ -503,7 +517,8 @@ def _apply_constraints_for_array_attributes(constraints, attr, cleaner, for_coun
                 index_name = COMMON_TAGS[item]
                 any_queries[f'#_common_tag_{index_name}'] = f"""
                 EXISTS(
-                    SELECT 1 FROM tag INDEXED BY tag_{index_name}_idx WHERE claim.claim_hash=tag.claim_hash
+                    SELECT 1 FROM tag INDEXED BY tag_{index_name}_idx
+                    WHERE {CLAIM_HASH_OR_REPOST_HASH_SQL}=tag.claim_hash
                     AND tag = '{item}'
                 )
                 """
@@ -516,7 +531,7 @@ def _apply_constraints_for_array_attributes(constraints, attr, cleaner, for_coun
             )
             any_queries[f'#_any_common_tags'] = f"""
             EXISTS(
-                SELECT 1 FROM tag WHERE claim.claim_hash=tag.claim_hash
+                SELECT 1 FROM tag WHERE {CLAIM_HASH_OR_REPOST_HASH_SQL}=tag.claim_hash
                 AND tag IN ({values})
             )
             """
@@ -530,14 +545,16 @@ def _apply_constraints_for_array_attributes(constraints, attr, cleaner, for_coun
             f':$any_{attr}{i}' for i in range(len(any_items))
         )
         if for_count or attr == 'tag':
-            any_queries[f'claim.claim_hash__in#_any_{attr}'] = f"""
-            SELECT claim_hash FROM {attr} WHERE {attr} IN ({values})
+            any_queries[f'#_any_{attr}'] = f"""
+            {CLAIM_HASH_OR_REPOST_HASH_SQL} IN (
+                SELECT claim_hash FROM {attr} WHERE {attr} IN ({values})
+            )
             """
         else:
             any_queries[f'#_any_{attr}'] = f"""
             EXISTS(
                 SELECT 1 FROM {attr} WHERE
-                    claim.claim_hash={attr}.claim_hash
+                    {CLAIM_HASH_OR_REPOST_HASH_SQL}={attr}.claim_hash
                 AND {attr} IN ({values})
             )
             """
@@ -556,15 +573,17 @@ def _apply_constraints_for_array_attributes(constraints, attr, cleaner, for_coun
             f':$all_{attr}{i}' for i in range(len(all_items))
         )
         if for_count:
-            constraints[f'claim.claim_hash__in#_all_{attr}'] = f"""
+            constraints[f'#_all_{attr}'] = f"""
+            {CLAIM_HASH_OR_REPOST_HASH_SQL} IN (
                 SELECT claim_hash FROM {attr} WHERE {attr} IN ({values})
                 GROUP BY claim_hash HAVING COUNT({attr}) = :$all_{attr}_count
+            )
             """
         else:
             constraints[f'#_all_{attr}'] = f"""
                 {len(all_items)}=(
                     SELECT count(*) FROM {attr} WHERE
-                        claim.claim_hash={attr}.claim_hash
+                        {CLAIM_HASH_OR_REPOST_HASH_SQL}={attr}.claim_hash
                     AND {attr} IN ({values})
                 )
             """
@@ -577,14 +596,16 @@ def _apply_constraints_for_array_attributes(constraints, attr, cleaner, for_coun
             f':$not_{attr}{i}' for i in range(len(not_items))
         )
         if for_count:
-            constraints[f'claim.claim_hash__not_in#_not_{attr}'] = f"""
+            constraints[f'#_not_{attr}'] = f"""
+            {CLAIM_HASH_OR_REPOST_HASH_SQL} NOT IN (
                 SELECT claim_hash FROM {attr} WHERE {attr} IN ({values})
+            )
             """
         else:
             constraints[f'#_not_{attr}'] = f"""
                 NOT EXISTS(
                     SELECT 1 FROM {attr} WHERE
-                        claim.claim_hash={attr}.claim_hash
+                        {CLAIM_HASH_OR_REPOST_HASH_SQL}={attr}.claim_hash
                     AND {attr} IN ({values})
                 )
             """
diff --git a/tests/integration/blockchain/test_claim_commands.py b/tests/integration/blockchain/test_claim_commands.py
index fcb6607dd..96ca3437b 100644
--- a/tests/integration/blockchain/test_claim_commands.py
+++ b/tests/integration/blockchain/test_claim_commands.py
@@ -829,8 +829,11 @@ class StreamCommands(ClaimTestCase):
         self.assertTrue(signed['outputs'][0]['is_channel_signature_valid'])
 
     async def test_repost(self):
+        sql = self.conductor.spv_node.server.bp.sql
+        sql.execute(sql.TAG_INDEXES)
+
         await self.channel_create('@goodies', '1.0')
-        tx = await self.stream_create('newstuff', '1.1', channel_name='@goodies')
+        tx = await self.stream_create('newstuff', '1.1', channel_name='@goodies', tags=['foo', 'gaming'])
         claim_id = self.get_claim_id(tx)
 
         self.assertEqual((await self.claim_search(name='newstuff'))[0]['meta']['reposted'], 0)
@@ -841,6 +844,16 @@ class StreamCommands(ClaimTestCase):
         self.assertEqual((await self.claim_search(name='newstuff'))[0]['meta']['reposted'], 1)
         self.assertEqual((await self.claim_search(reposted_claim_id=claim_id))[0]['claim_id'], repost_id)
 
+        # tags are inherited (non-common / indexed tags)
+        self.assertItemCount(await self.daemon.jsonrpc_claim_search(any_tags=['foo'], claim_type=['stream', 'repost']), 2)
+        self.assertItemCount(await self.daemon.jsonrpc_claim_search(all_tags=['foo'], claim_type=['stream', 'repost']), 2)
+        self.assertItemCount(await self.daemon.jsonrpc_claim_search(not_tags=['foo'], claim_type=['stream', 'repost']), 0)
+        # "common" / indexed tags work too
+        self.assertIn('gaming', sql.TAG_INDEXES)  # if this breaks, next test doesn't make sense
+        self.assertItemCount(await self.daemon.jsonrpc_claim_search(any_tags=['gaming'], claim_type=['stream', 'repost']), 2)
+        self.assertItemCount(await self.daemon.jsonrpc_claim_search(all_tags=['gaming'], claim_type=['stream', 'repost']), 2)
+        self.assertItemCount(await self.daemon.jsonrpc_claim_search(not_tags=['gaming'], claim_type=['stream', 'repost']), 0)
+
         await self.channel_create('@reposting-goodies', '1.0')
         await self.stream_repost(claim_id, 'repost-on-channel', '1.1', channel_name='@reposting-goodies')
         self.assertItemCount(await self.daemon.jsonrpc_claim_list(claim_type='repost'), 2)
@@ -948,9 +961,9 @@ class StreamCommands(ClaimTestCase):
         result = await self.out(self.daemon.jsonrpc_claim_search(any_tags=['bad-stuff'], order_by=['height']))
         filtered = result['blocked']
         self.assertEqual(0, len(result['items']))
-        self.assertEqual(2, filtered['total'])
+        self.assertEqual(3, filtered['total'])
         self.assertEqual(1, len(filtered['channels']))
-        self.assertEqual(2, filtered['channels'][0]['blocked'])
+        self.assertEqual(3, filtered['channels'][0]['blocked'])
         self.assertTrue(filtered['channels'][0]['channel']['short_url'].startswith('lbry://@filtering#'))
 
         # filtered channel should still resolve