diff --git a/app/src/api.js b/app/src/api.js
index 142f7ec3..8b2a421b 100644
--- a/app/src/api.js
+++ b/app/src/api.js
@@ -2118,8 +2118,8 @@ export async function searchEstimateOthers(tagNames, searchStr) {
     }
 }
 
-export async function searchChannels(tagNames) {
-    const body = {tag_names: tagNames};
+export async function searchChannels(tagNames, searchStr) {
+    const body = {tag_names: tagNames, search_str: searchStr};
     const response = await apiPost(`${API_URI}/videos/channels/search`, body);
     if (response.ok) {
         const content = await response.json();
@@ -2129,6 +2129,16 @@ export async function searchChannels(tagNames) {
     }
 }
 
+// Collections of `kind` whose name matches `searchStr` and/or which have any of the tags.
+export async function searchCollections(kind, tagNames, searchStr) {
+    const body = {kind, tag_names: tagNames, search_str: searchStr};
+    const response = await apiPost(`${COLLECTIONS_API}/search`, body);
+    if (response.ok) {
+        const content = await response.json();
+        return {collections: content.collections};
+    }
+}
+
 export async function getOutdatedZims() {
     const response = await apiGet(`${API_URI}/zim/outdated`);
     if (response.status === 200) {
diff --git a/app/src/components/OtherSearchView.test.js b/app/src/components/OtherSearchView.test.js
index e2526ec3..c4de3dc9 100644
--- a/app/src/components/OtherSearchView.test.js
+++ b/app/src/components/OtherSearchView.test.js
@@ -1,7 +1,7 @@
 import React from 'react';
 import {act, render, screen} from '../test-utils';
 import {OtherSearchView} from './Search';
-import {searchChannels, searchRepos} from '../api';
+import {searchChannels, searchCollections, searchRepos} from '../api';
 
 // What the search page's Other tab shows for each state of useSearchChannels.  "No Channels"
 // must only appear once the server has confirmed there are none.
@@ -9,6 +9,7 @@ import {searchChannels, searchRepos} from '../api';
 jest.mock('../api', () => ({
     ...jest.requireActual('../api'),
     searchChannels: jest.fn(),
+    searchCollections: jest.fn(),
     searchRepos: jest.fn(),
 }));
 
@@ -18,6 +19,8 @@ beforeEach(() => {
     searchChannels.mockReset();
     searchRepos.mockReset();
     searchRepos.mockResolvedValue({repos: [], total: 0});
+    searchCollections.mockReset();
+    searchCollections.mockResolvedValue({collections: []});
 });
 
 test('pending: shows a loader, not "No Channels"', () => {
@@ -117,3 +120,55 @@ describe('Repos', () => {
         expect(screen.getByText(/files <script>/)).toBeInTheDocument();
     });
 });
+
+// Domains and Playlists are Collections searched by kind.
+describe.each([
+    ['domain', 'Domains', 'example.com', '/archives?domain=example.com'],
+    ['playlist', 'Playlists', 'Road Trip', '/playlists/3'],
+])('%s Collections', (kind, title, name, href) => {
+    const collectionsOf = (wanted, collections) => (k) => Promise.resolve({collections: k === wanted ? collections : []});
+
+    test(`empty: shows "No ${title}"`, async () => {
+        searchChannels.mockResolvedValue({channels: []});
+        render(<OtherSearchView loading={false}/>, {query: {searchParams: new URLSearchParams('q=nothing')}});
+        await act(async () => {
+        });
+        expect(screen.getByText(`No ${title}`)).toBeInTheDocument();
+    });
+
+    test('nothing to search by: shows none without fetching', async () => {
+        searchChannels.mockResolvedValue({channels: []});
+        render(<OtherSearchView loading={false}/>);
+        await act(async () => {
+        });
+        expect(screen.getByText(`No ${title}`)).toBeInTheDocument();
+        expect(searchCollections).not.toHaveBeenCalled();
+    });
+
+    test(`failed: shows an error only in the ${title} section`, async () => {
+        searchChannels.mockResolvedValue({channels: [{id: 1, name: 'Cooking'}]});
+        searchCollections.mockImplementation(k => k === kind ? Promise.reject(new Error('boom')) : Promise.resolve({collections: []}));
+        const spy = jest.spyOn(console, 'error').mockImplementation(() => {
+        });
+        try {
+            render(<OtherSearchView loading={false}/>, {query: {searchParams: new URLSearchParams('q=x')}});
+            await act(async () => {
+            });
+            expect(screen.getByText('Cooking')).toBeInTheDocument();
+            expect(screen.getByText(new RegExp(`Could not fetch the ${title.toLowerCase()}`))).toBeInTheDocument();
+        } finally {
+            spy.mockRestore();
+        }
+    });
+
+    test('loaded: lists them by the search and tags, linked', async () => {
+        searchChannels.mockResolvedValue({channels: []});
+        searchCollections.mockImplementation(collectionsOf(kind, [{id: 3, name, kind, tag_name: null}]));
+        const searchParams = new URLSearchParams('q=road&tag=News');
+        render(<OtherSearchView loading={false}/>, {query: {searchParams}});
+        await act(async () => {
+        });
+        expect(searchCollections).toHaveBeenCalledWith(kind, ['News'], 'road');
+        expect(screen.getByText(name).closest('a')).toHaveAttribute('href', href);
+    });
+});
diff --git a/app/src/components/Search.js b/app/src/components/Search.js
index 727ef304..6d76b1c7 100644
--- a/app/src/components/Search.js
+++ b/app/src/components/Search.js
@@ -8,6 +8,7 @@ import {
     useSearchDate,
     useSearchDeep,
     useSearchFilter,
+    useSearchCollections,
     useSearchRepos,
 } from "../hooks/customHooks";
 import {ShortcutHint} from "./ShortcutHint";
@@ -562,6 +563,16 @@ function SearchChannelPreview({channel}) {
     </div>
 }
 
+function SearchCollectionPreview({collection, to}) {
+    const {SingleTag} = React.useContext(TagsContext);
+    return <div>
+        <span style={{display: 'inline-flex', alignItems: 'center', gap: 8, flexWrap: 'wrap'}}>
+            <Link to={to}>{collection.name}</Link>
+            {collection.tag_name && <SingleTag name={collection.tag_name}/>}
+        </span>
+    </div>
+}
+
 function SearchRepoPreview({repo}) {
     const {SingleTag} = React.useContext(TagsContext);
     return <div>
@@ -594,14 +605,16 @@ function OtherSearchSection({value, title, items, preview, emptyText, errorText}
     </Accordion.Item>
 }
 
-// `channels` follows useSearchChannels and `repos` follows useSearchRepos: null = pending,
+// Each section's items follow useSearchChannels, useSearchCollections, or useSearchRepos: null = pending,
 // undefined = fetch failed, [] = none.
 export function OtherSearchView({loading}) {
     const {searchParams} = React.useContext(QueryContext);
-    const [activeValues, setActiveValues] = React.useState(['channels', 'repos']);
+    const [activeValues, setActiveValues] = React.useState(['channels', 'domains', 'playlists', 'repos']);
     const activeTags = searchParams.getAll('tag');
     const searchStr = searchParams.get('q') || '';
-    const {channels, loading: channelsLoading} = useSearchChannels(activeTags);
+    const {channels, loading: channelsLoading} = useSearchChannels(activeTags, searchStr);
+    const {collections: domains} = useSearchCollections('domain', searchStr, activeTags);
+    const {collections: playlists} = useSearchCollections('playlist', searchStr, activeTags);
     const {repos} = useSearchRepos(searchStr, activeTags);
 
     if (loading || channelsLoading || channels === null) {
@@ -619,6 +632,23 @@ export function OtherSearchView({loading}) {
             emptyText='No Channels'
             errorText='Could not fetch the channels.'
         />
+        <OtherSearchSection
+            value='domains'
+            title='Domains'
+            items={domains}
+            preview={i => <SearchCollectionPreview key={i.id} collection={i}
+                                                   to={`/archives?domain=${encodeURIComponent(i.name)}`}/>}
+            emptyText='No Domains'
+            errorText='Could not fetch the domains.'
+        />
+        <OtherSearchSection
+            value='playlists'
+            title='Playlists'
+            items={playlists}
+            preview={i => <SearchCollectionPreview key={i.id} collection={i} to={`/playlists/${i.id}`}/>}
+            emptyText='No Playlists'
+            errorText='Could not fetch the playlists.'
+        />
         <OtherSearchSection
             value='repos'
             title='Repos'
diff --git a/app/src/hooks/customHooks.js b/app/src/hooks/customHooks.js
index 45bd8697..84339fca 100644
--- a/app/src/hooks/customHooks.js
+++ b/app/src/hooks/customHooks.js
@@ -36,6 +36,7 @@ import {
     saveSettings,
     searchArchives,
     searchChannels,
+    searchCollections,
     searchDirectories,
     searchDocs,
     searchRepos,
@@ -2107,7 +2108,8 @@ export const useCalcQuery = () => {
     return [calc, setCalc]
 }
 
-export const useSearchChannels = (defaultTagNames) => {
+// Channels whose name matches `searchStr` and/or which have any of the tags.
+export const useSearchChannels = (defaultTagNames, searchStr) => {
     const [tagNames, setTagNames] = useState(defaultTagNames || []);
     // null = pending, undefined = fetch failed, [] = no channels.  A search starts on mount, so the
     // first render is already loading; consumers must never see [] for a search that has not run.
@@ -2121,7 +2123,7 @@ export const useSearchChannels = (defaultTagNames) => {
         setChannels(null);
         setLoading(true);
         try {
-            const {channels: newChannels} = await searchChannels(tagNames);
+            const {channels: newChannels} = await searchChannels(tagNames, searchStr);
             if (gen === requestGen.current) {
                 setChannels(newChannels || []);
             }
@@ -2147,7 +2149,7 @@ export const useSearchChannels = (defaultTagNames) => {
 
     useEffect(() => {
         localSearchChannels();
-    }, [tagNames]);
+    }, [tagNames, searchStr]);
 
     return {
         tagNames,
@@ -2157,6 +2159,33 @@ export const useSearchChannels = (defaultTagNames) => {
     }
 }
 
+// Collections of `kind` whose name matches `searchStr` and/or which have any of the tags.  `collections`:
+// null = pending, undefined = fetch failed, [] = none.  Nothing to search by matches nothing (the API would list
+// every Collection of the kind).  Only the newest request may write state.
+export const useSearchCollections = (kind, searchStr, tagNames) => {
+    const [collections, setCollections] = useState(null);
+    const requestGen = useRef(0);
+    const tagKey = JSON.stringify(tagNames || []);
+
+    useEffect(() => {
+        const gen = ++requestGen.current;
+        const tags = JSON.parse(tagKey);
+        if (!(searchStr || '').trim() && _.isEmpty(tags)) {
+            setCollections([]);
+            return;
+        }
+        setCollections(null);
+        searchCollections(kind, tags, searchStr)
+            .then(result => gen === requestGen.current && setCollections(result ? result.collections : undefined))
+            .catch(e => {
+                console.error(e);
+                if (gen === requestGen.current) setCollections(undefined);
+            });
+    }, [kind, searchStr, tagKey]);
+
+    return {collections};
+}
+
 // Repos matching the search (their name and README) and/or the tags.  `repos`: null = pending,
 // undefined = fetch failed, [] = none.  Only the newest request may write state.
 export const useSearchRepos = (searchStr, tagNames) => {
diff --git a/app/src/hooks/customHooks.test.js b/app/src/hooks/customHooks.test.js
index 9f26d925..0652557a 100644
--- a/app/src/hooks/customHooks.test.js
+++ b/app/src/hooks/customHooks.test.js
@@ -475,7 +475,7 @@ describe('useSearchChannels', () => {
         const {result} = renderHook(() => useSearchChannels(['a']));
         await act(async () => {
         });
-        expect(searchChannels).toHaveBeenCalledWith(['a']);
+        expect(searchChannels).toHaveBeenCalledWith(['a'], undefined);
         expect(result.current.channels).toEqual([{id: 1, name: 'One'}]);
         expect(result.current.loading).toBe(false);
     });
@@ -510,11 +510,27 @@ describe('useSearchChannels', () => {
         }));
         rerender({tags: ['new']});
         expect(searchChannels).toHaveBeenCalledTimes(2);
-        expect(searchChannels).toHaveBeenLastCalledWith(['new']);
+        expect(searchChannels).toHaveBeenLastCalledWith(['new'], undefined);
         expect(result.current.channels).toBeNull();
         expect(result.current.loading).toBe(true);
     });
 
+    test('searches by the search text, and refetches when it changes', async () => {
+        searchChannels.mockResolvedValue({channels: [{id: 1, name: 'Cooking'}]});
+        const {result, rerender} = renderHook(({q}) => useSearchChannels([], q), {initialProps: {q: 'cook'}});
+        await act(async () => {
+        });
+        expect(searchChannels).toHaveBeenLastCalledWith([], 'cook');
+        expect(result.current.channels).toEqual([{id: 1, name: 'Cooking'}]);
+
+        searchChannels.mockReturnValue(new Promise(() => {
+        }));
+        rerender({q: 'garden'});
+        expect(searchChannels).toHaveBeenCalledTimes(2);
+        expect(searchChannels).toHaveBeenLastCalledWith([], 'garden');
+        expect(result.current.channels).toBeNull();
+    });
+
     test('a new array with the same tags does not refetch', async () => {
         searchChannels.mockResolvedValue({channels: []});
         const {rerender} = renderHook(({tags}) => useSearchChannels(tags), {initialProps: {tags: ['a']}});
diff --git a/modules/repos/test/test_search.py b/modules/repos/test/test_search.py
index fc42623f..9ff59f0d 100644
--- a/modules/repos/test/test_search.py
+++ b/modules/repos/test/test_search.py
@@ -116,13 +116,13 @@ async def test_search_api(test_session, async_client, test_wrolpi_config):
 
     # The global search's "Other" estimate counts Repos by the search, and by Tag.
     request, response = await async_client.post('/api/search_other_estimates', content=json.dumps(body))
-    assert response.json['others'] == dict(channel_count=0, repo_count=1)
+    assert response.json['others'] == dict(channel_count=0, domain_count=0, playlist_count=0, repo_count=1)
     body = dict(tag_names=['software'])
     request, response = await async_client.post('/api/search_other_estimates', content=json.dumps(body))
-    assert response.json['others'] == dict(channel_count=0, repo_count=1)
+    assert response.json['others'] == dict(channel_count=0, domain_count=0, playlist_count=0, repo_count=1)
     body = dict(tag_names=['software'], search_str='nothing')
     request, response = await async_client.post('/api/search_other_estimates', content=json.dumps(body))
-    assert response.json['others'] == dict(channel_count=0, repo_count=0)
+    assert response.json['others'] == dict(channel_count=0, domain_count=0, playlist_count=0, repo_count=0)
 
     # Repos are suggested by name.
     request, response = await async_client.post('/api/search_suggestions', content=json.dumps(dict(search_str='kiw')))
diff --git a/modules/videos/channel/api.py b/modules/videos/channel/api.py
index 77efa479..50a52023 100644
--- a/modules/videos/channel/api.py
+++ b/modules/videos/channel/api.py
@@ -145,7 +145,7 @@ async def channel_tag(request: Request, channel_id: int, body: schema.ChannelTag
 @validate(schema.ChannelSearchRequest)
 async def channel_search(request: Request, body: schema.ChannelSearchRequest):
     session = request.ctx.session
-    channels = await lib.search_channels(session, body.tag_names)
+    channels = await lib.search_channels(session, body.tag_names, body.search_str)
     ret = dict(
         channels=channels,
     )
diff --git a/modules/videos/channel/lib.py b/modules/videos/channel/lib.py
index b4e983e2..c514c5da 100644
--- a/modules/videos/channel/lib.py
+++ b/modules/videos/channel/lib.py
@@ -1,9 +1,9 @@
 import pathlib
 from pathlib import Path
-from typing import List, Union
+from typing import List, Optional, Union
 
 from sqlalchemy import or_, func, desc
-from sqlalchemy.orm import Session, joinedload
+from sqlalchemy.orm import Query, Session, joinedload
 
 from wrolpi import flags
 from wrolpi.collections import Collection
@@ -330,8 +330,27 @@ async def tag_channel(session: Session, tag_name: str | None, directory: pathlib
         save_channels_config.activate_switch()
 
 
-async def search_channels(session: Session, tag_names: List[str]) -> List[Channel]:
-    """Search Tagged Channels."""
-    channels = session.query(Channel).options(*Channel.json_options()) \
-        .join(Collection).join(Tag).filter(Tag.name.in_(tag_names)).all()
-    return channels
+def search_channels_query(session: Session, tag_names: List[str] = None, search_str: str = None) -> Optional[Query]:
+    """Channels whose name contains `search_str` and which have any of the Tags.  None when there is nothing to search
+    by."""
+    search_str = (search_str or '').strip()
+    if not tag_names and not search_str:
+        return None
+    query = session.query(Channel).join(Collection, Collection.id == Channel.collection_id)
+    if search_str:
+        name_no_spaces = ''.join(search_str.split(' '))
+        query = query.filter(or_(
+            Collection.name.ilike(f'%{search_str}%'),
+            Collection.name.ilike(f'%{name_no_spaces}%'),
+        ))
+    if tag_names:
+        query = query.join(Tag, Tag.id == Collection.tag_id).filter(Tag.name.in_(tag_names))
+    return query
+
+
+async def search_channels(session: Session, tag_names: List[str] = None, search_str: str = None) -> List[Channel]:
+    """Search Channels by their name and/or Tags."""
+    query = search_channels_query(session, tag_names, search_str)
+    if query is None:
+        return []
+    return query.options(*Channel.json_options()).order_by(func.lower(Collection.name)).all()
diff --git a/modules/videos/channel/test/test_api.py b/modules/videos/channel/test/test_api.py
index 883f41bf..578a5a85 100644
--- a/modules/videos/channel/test/test_api.py
+++ b/modules/videos/channel/test/test_api.py
@@ -721,3 +721,32 @@ async def test_search_tagged_channels(async_client, test_session, channel_factor
     assert response.status_code == HTTPStatus.OK
     assert len(response.json['channels']) == 1, 'Only one Channel is tagged'
     assert response.json['channels'][0]['id'] == channel1.id
+
+
+@pytest.mark.asyncio
+async def test_search_channels_by_name(async_client, test_session, channel_factory, tag_factory):
+    """Channels can be searched by their name, alone or with Tags."""
+    tag = await tag_factory()
+    cooking = channel_factory(name='Cooking Show', tag_name=tag.name)
+    channel_factory(name='Cooking Basics')
+    channel_factory(name='Gardening')
+    test_session.commit()
+
+    async def search(body):
+        request, response = await async_client.post('/api/videos/channels/search', json=body)
+        assert response.status_code == HTTPStatus.OK
+        return sorted(i['name'] for i in response.json['channels'])
+
+    assert await search(dict(search_str='cooking')) == ['Cooking Basics', 'Cooking Show']
+    # The name and the Tags must both match.
+    assert await search(dict(search_str='cooking', tag_names=[tag.name])) == ['Cooking Show']
+    assert await search(dict(search_str='gardening', tag_names=[tag.name])) == []
+    # Nothing to search by matches nothing.
+    assert await search(dict(search_str='')) == []
+    assert await search(dict()) == []
+
+    # The Other tab's estimate counts the same Channels.
+    for body in (dict(search_str='cooking'), dict(search_str='cooking', tag_names=[tag.name]), dict(search_str='')):
+        request, response = await async_client.post('/api/search_other_estimates', json=body)
+        assert response.status_code == HTTPStatus.OK
+        assert response.json['others']['channel_count'] == len(await search(body)), body
diff --git a/modules/videos/schema.py b/modules/videos/schema.py
index f3a73d80..0845b7db 100644
--- a/modules/videos/schema.py
+++ b/modules/videos/schema.py
@@ -266,6 +266,7 @@ class CensoredVideoResponse:
 @dataclass
 class ChannelSearchRequest:
     tag_names: List[str] = field(default_factory=list)
+    search_str: Optional[str] = None
 
 
 @dataclass
diff --git a/wrolpi/collections/lib.py b/wrolpi/collections/lib.py
index 08cc055f..d18d77f0 100644
--- a/wrolpi/collections/lib.py
+++ b/wrolpi/collections/lib.py
@@ -8,7 +8,7 @@ import pathlib
 from typing import List, Optional, Dict
 
 from sqlalchemy import func
-from sqlalchemy.orm import Session, selectinload, noload
+from sqlalchemy.orm import Query, Session, selectinload, noload
 
 from wrolpi import flags
 from wrolpi.common import get_media_directory, logger, get_relative_to_media_directory, TRACE_LEVEL, background_task
@@ -871,42 +871,35 @@ def delete_collection(
     return collection_dict
 
 
+def search_collections_query(
+        session: Session,
+        kind: Optional[str] = None,
+        tag_names: Optional[List[str]] = None,
+        search_str: Optional[str] = None,
+) -> Query:
+    """Collections of `kind` whose name contains `search_str` and which have any of the Tags.  A missing filter
+    matches every Collection."""
+    query = session.query(Collection)
+    if kind:
+        query = query.filter(Collection.kind == kind)
+    if tag_names:
+        query = query.join(Tag, Tag.id == Collection.tag_id).filter(Tag.name.in_(tag_names))
+    if search_str:
+        query = query.filter(Collection.name.ilike(f'%{search_str}%'))
+    return query
+
+
 def search_collections(
         session: Session,
         kind: Optional[str] = None,
         tag_names: Optional[List[str]] = None,
         search_str: Optional[str] = None,
 ) -> List[dict]:
-    """
-    Search collections by kind, tags, and search string.
-
-    Args:
-        session: Database session
-        kind: Optional collection kind filter
-        tag_names: Optional list of tag names to filter by
-        search_str: Optional search string for collection names
-
-    Returns:
-        List of matching collection dicts
-    """
-    query = session.query(Collection)
-
-    # Filter by kind
-    if kind:
-        query = query.filter(Collection.kind == kind)
-
-    # Filter by tags
-    if tag_names:
-        query = query.join(Tag).filter(Tag.name.in_(tag_names))
-
-    # Filter by search string
-    if search_str:
-        query = query.filter(Collection.name.ilike(f'%{search_str}%'))
-
-    # Order by name
-    query = query.order_by(Collection.name)
-
-    collections = query.all()
+    """Search Collections by kind, Tags, and name (see `search_collections_query`)."""
+    collections = search_collections_query(session, kind, tag_names, search_str) \
+        .options(*Collection.json_options()) \
+        .order_by(Collection.name) \
+        .all()
     return [collection.__json__() for collection in collections]
 
 
diff --git a/wrolpi/collections/test/test_collection_search.py b/wrolpi/collections/test/test_collection_search.py
new file mode 100644
index 00000000..bbd3709a
--- /dev/null
+++ b/wrolpi/collections/test/test_collection_search.py
@@ -0,0 +1,47 @@
+from http import HTTPStatus
+
+import pytest
+
+from wrolpi.collections import Collection
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize('kind', ['domain', 'playlist'])
+async def test_search_collections_other_estimate(async_client, test_session, tag_factory, kind):
+    """Collections can be searched by kind, name, and/or Tags; the Other tab's estimate counts the same
+    Collections."""
+    tag1, tag2 = await tag_factory(), await tag_factory()
+    test_session.add_all([
+        Collection(name='cooking one', kind=kind, tag=tag1),
+        Collection(name='cooking two', kind=kind),
+        Collection(name='gardening', kind=kind, tag=tag2),
+        # Another kind is never counted.
+        Collection(name='cooking other', kind='channel' if kind == 'domain' else 'domain', tag=tag1),
+    ])
+    test_session.commit()
+
+    async def search(body):
+        request, response = await async_client.post('/api/collections/search', json=dict(body, kind=kind))
+        assert response.status_code == HTTPStatus.OK
+        return sorted(i['name'] for i in response.json['collections'])
+
+    cases = [
+        (dict(search_str='cooking'), ['cooking one', 'cooking two']),
+        (dict(tag_names=[tag1.name]), ['cooking one']),
+        # Any of the Tags.
+        (dict(tag_names=[tag1.name, tag2.name]), ['cooking one', 'gardening']),
+        # The name and the Tags must both match.
+        (dict(search_str='garden', tag_names=[tag2.name]), ['gardening']),
+        (dict(search_str='cooking', tag_names=[tag2.name]), []),
+    ]
+    count_key = f'{kind}_count'
+    for body, expected in cases:
+        assert await search(body) == expected, body
+        request, response = await async_client.post('/api/search_other_estimates', json=body)
+        assert response.status_code == HTTPStatus.OK
+        assert response.json['others'][count_key] == len(expected), body
+
+    # Nothing to search by: the Other tab shows none (the search endpoint lists every Collection of the kind).
+    for body in (dict(search_str=''), dict(search_str='  '), dict()):
+        request, response = await async_client.post('/api/search_other_estimates', json=body)
+        assert response.json['others'][count_key] == 0, body
diff --git a/wrolpi/common.py b/wrolpi/common.py
index c6ea4af2..11bd80c9 100644
--- a/wrolpi/common.py
+++ b/wrolpi/common.py
@@ -2870,31 +2870,26 @@ def extract_headlines(entries: List[str], search_str: str) -> List[Tuple[str, fl
 
 
 async def search_other_estimates(session: Session, tag_names: List[str], search_str: str = None) -> dict:
-    """Estimate other things that are Tagged, or match the search (Repos by their name and README)."""
-    from sqlalchemy import func
-    from wrolpi.collections.models import Collection
-    from wrolpi.tags import Tag
-    from modules.videos.models import Channel
+    """Estimate other things that match the search or the Tags (Channels, Domains, and Playlists by their name, Repos
+    by their name and README)."""
+    from modules.videos.channel.lib import search_channels_query
     from modules.repos.lib import count_repos
+    from wrolpi.collections.lib import search_collections_query
 
-    repo_count = count_repos(session, search_str, tag_names)
+    search_str = (search_str or '').strip()
+    channels = search_channels_query(session, tag_names, search_str)
 
-    if not tag_names:
-        return dict(
-            channel_count=0,
-            repo_count=repo_count,
-        )
-
-    # TODO handle multiple tags
-    channel_count = session.query(func.count(Channel.id)) \
-        .join(Collection, Collection.id == Channel.collection_id) \
-        .join(Tag, Tag.id == Collection.tag_id) \
-        .filter(Tag.name == tag_names[0]) \
-        .scalar()
+    def count_collections(kind: str) -> int:
+        # Nothing to search by matches nothing, like the other searches.
+        if not tag_names and not search_str:
+            return 0
+        return search_collections_query(session, kind, tag_names, search_str).count()
 
     others = dict(
-        channel_count=channel_count,
-        repo_count=repo_count,
+        channel_count=channels.count() if channels is not None else 0,
+        domain_count=count_collections('domain'),
+        playlist_count=count_collections('playlist'),
+        repo_count=count_repos(session, search_str, tag_names),
     )
     return others
 
diff --git a/wrolpi/test/test_root_api.py b/wrolpi/test/test_root_api.py
index 055e7364..a8163666 100644
--- a/wrolpi/test/test_root_api.py
+++ b/wrolpi/test/test_root_api.py
@@ -1016,6 +1016,18 @@ async def test_search_other_estimates(async_client, test_session, channel_factor
     assert response.status_code == HTTPStatus.OK
     assert response.json['others']['channel_count'] == 1, 'Only one Channel is tagged.'
 
+    # The estimate counts the Channels the search lists: those with any of the Tags.
+    tag2 = await tag_factory()
+    channel_factory(tag_name=tag2.name)
+    test_session.commit()
+    body = dict(tag_names=[tag.name, tag2.name])
+    request, response = await async_client.post('/api/search_other_estimates', json=body)
+    assert response.status_code == HTTPStatus.OK
+    estimate = response.json['others']['channel_count']
+    request, response = await async_client.post('/api/videos/channels/search', json=body)
+    assert response.status_code == HTTPStatus.OK
+    assert estimate == len(response.json['channels']) == 2
+
 
 @pytest.mark.asyncio
 async def test_mutating_request_survives_concurrent_writer(async_client, test_session, test_downloader,