diff --git a/datalad_registry/blueprints/api/dataset_urls/__init__.py b/datalad_registry/blueprints/api/dataset_urls/__init__.py
index 85005609..cff6f476 100644
--- a/datalad_registry/blueprints/api/dataset_urls/__init__.py
+++ b/datalad_registry/blueprints/api/dataset_urls/__init__.py
@@ -9,7 +9,7 @@
 from flask_openapi3 import APIBlueprint, Tag
 from lark.exceptions import GrammarError, UnexpectedInput
 from psycopg2.errors import UniqueViolation
-from sqlalchemy import ColumnElement, and_
+from sqlalchemy import ColumnElement, and_, select
 from sqlalchemy.exc import IntegrityError
 
 from datalad_registry.models import RepoUrl, db
@@ -32,6 +32,7 @@
     PathParams,
     QueryParams,
 )
+from .tools import get_collection_stats
 from .. import (
     API_URL_PREFIX,
     COMMON_API_RESPONSES,
@@ -92,7 +93,7 @@ def declare_dataset_url(body: DatasetURLSubmitModel):
     url_as_str = str(body.url)
 
     repo_url_row = db.session.execute(
-        db.select(RepoUrl).filter_by(url=url_as_str)
+        select(RepoUrl).filter_by(url=url_as_str)
     ).one_or_none()
     if repo_url_row is None:
         # == The URL requested to be created does not exist in the database ==
@@ -116,7 +117,7 @@ def declare_dataset_url(body: DatasetURLSubmitModel):
                     # of the URL in the database
                     db.session.rollback()
                     repo_url_added_by_another = (
-                        db.session.execute(db.select(RepoUrl).filter_by(url=url_as_str))
+                        db.session.execute(select(RepoUrl).filter_by(url=url_as_str))
                         .scalars()
                         .one_or_none()
                     )
@@ -285,11 +286,11 @@ def cache_path_trans(cache_path: Path) -> str:
     ep = ".dataset_urls"  # Endpoint of `dataset_urls`
     base_qry = loads(query.json(exclude={"page"}, exclude_none=True))
 
+    base_select_stmt = select(RepoUrl).filter(and_(True, *constraints))
+
     max_per_page = 100  # The overriding limit to `per_page` provided by the requester
     pagination = db.paginate(
-        db.select(RepoUrl)
-        .filter(and_(True, *constraints))
-        .order_by(
+        base_select_stmt.order_by(
             getattr(
                 _ORDER_KEY_TO_SQLA_ATTR[query.order_by], query.order_dir.value
             )().nulls_last()
@@ -341,7 +342,6 @@ def cache_path_trans(cache_path: Path) -> str:
     assert pagination.total is not None
 
     page = DatasetURLPage(
-        total=pagination.total,
         cur_pg_num=cur_pg_num,
         prev_pg=(
             url_for(ep, **base_qry, page=pagination.prev_num)
@@ -356,6 +356,7 @@ def cache_path_trans(cache_path: Path) -> str:
         first_pg=url_for(ep, **base_qry, page=1),
         last_pg=url_for(ep, **base_qry, page=1 if total_pages == 0 else total_pages),
         dataset_urls=ds_urls,
+        collection_stats=get_collection_stats(base_select_stmt),
     )
 
     return json_resp_from_str(page.json(exclude_none=True))
diff --git a/datalad_registry/blueprints/api/dataset_urls/models.py b/datalad_registry/blueprints/api/dataset_urls/models.py
index ca000424..d6f3773b 100644
--- a/datalad_registry/blueprints/api/dataset_urls/models.py
+++ b/datalad_registry/blueprints/api/dataset_urls/models.py
@@ -9,6 +9,7 @@
     BaseModel,
     Field,
     FileUrl,
+    NonNegativeInt,
     PositiveInt,
     StrictInt,
     StrictStr,
@@ -256,14 +257,74 @@ class Config:
         by_alias = False
 
 
+class AnnexDsCollectionStats(BaseModel):
+    """
+    Model with the base components of annex dataset collection statistics
+    """
+
+    ds_count: NonNegativeInt = Field(description="The number of datasets")
+    annexed_files_size: Optional[NonNegativeInt] = Field(
+        None, description="The size of annexed files"
+    )
+    annexed_file_count: Optional[NonNegativeInt] = Field(
+        None, description="The number of annexed files"
+    )
+
+
+class DataladDsCollectionStats(BaseModel):
+    """
+    Model for DataLad dataset collection statistics
+    """
+
+    unique_ds_stats: AnnexDsCollectionStats = Field(
+        description="Statistics for unique datasets"
+    )
+    stats: AnnexDsCollectionStats = Field(
+        description="Statistics for all datasets, as individual repos, "
+        "without any deduplication"
+    )
+
+
+class NonAnnexDsCollectionStats(BaseModel):
+    """
+    Model for non-annex dataset collection statistics
+    """
+
+    ds_count: NonNegativeInt = Field(
+        description="The number of datasets, as individual repos, "
+        "without any deduplication"
+    )
+
+
+class StatsSummary(BaseModel):
+    unique_ds_count: NonNegativeInt = Field(description="The number of unique datasets")
+    ds_count: NonNegativeInt = Field(
+        description="The number of datasets, as individual repos, "
+        "without any deduplication"
+    )
+
+
+class CollectionStats(BaseModel):
+    datalad_ds_stats: DataladDsCollectionStats = Field(
+        description="Statistics for DataLad datasets"
+    )
+    pure_annex_ds_stats: AnnexDsCollectionStats = Field(
+        description="Statistics for pure annex datasets, as individual repos, "
+        "without any deduplication"
+    )
+    non_annex_ds_stats: NonAnnexDsCollectionStats = Field(
+        description="Statistics for non-annex datasets, as individual repos, "
+        "without any deduplication"
+    )
+
+    summary: StatsSummary = Field(description="Summary statistics")
+
+
 class DatasetURLPage(BaseModel):
     """
     Model for representing a page of dataset URLs in response communication
     """
 
-    total: StrictInt = Field(
-        description="The total number of dataset URLs across all pages"
-    )
     cur_pg_num: StrictInt = Field(description="The number of the current page")
     prev_pg: Optional[StrictStr] = Field(
         None, description="The link to the previous page"
@@ -275,3 +336,8 @@ class DatasetURLPage(BaseModel):
     dataset_urls: list[DatasetURLRespModel] = Field(
         description="The list of dataset URLs in the current page"
     )
+    collection_stats: CollectionStats = Field(
+        description="Statistics about the collection of dataset URLs, "
+        "not just the URLs in the current page but the entire collection "
+        "returned"
+    )
diff --git a/datalad_registry/blueprints/api/dataset_urls/tools.py b/datalad_registry/blueprints/api/dataset_urls/tools.py
new file mode 100644
index 00000000..6d518cb1
--- /dev/null
+++ b/datalad_registry/blueprints/api/dataset_urls/tools.py
@@ -0,0 +1,238 @@
+from sqlalchemy import (
+    Select,
+    Subquery,
+    TableClause,
+    and_,
+    column,
+    func,
+    not_,
+    or_,
+    select,
+    table,
+    text,
+)
+
+from datalad_registry.models import RepoUrl, db
+
+from .models import (
+    AnnexDsCollectionStats,
+    CollectionStats,
+    DataladDsCollectionStats,
+    NonAnnexDsCollectionStats,
+    StatsSummary,
+)
+
+
+def cache_result_to_tmp_tb(select_stmt: Select, tb_name: str) -> TableClause:
+    """
+    Execute the given select statement and cache the result to a temporary table
+    with the given name
+
+    :param select_stmt: The given select statement to execute
+    :param tb_name: The string to use as the name of the temporary table
+    :return: A object representing the temporary table
+
+    Note: The execution of this function requires the Flask app's context
+    """
+    create_tmp_tb_sql = f"""
+        CREATE TEMPORARY TABLE {tb_name} AS
+        {select_stmt.compile(bind=db.engine, compile_kwargs={'literal_binds': True})};
+    """
+    db.session.execute(text(create_tmp_tb_sql))
+
+    return table(
+        tb_name,
+        *(column(name, c.type) for name, c in select_stmt.selected_columns.items()),
+    )
+
+
+def _get_annex_ds_collection_stats(q: Subquery) -> AnnexDsCollectionStats:
+    """
+    Get the stats of a collection of datasets that contains only of annex datasets
+
+    :param q: The query that specifies the collection of datasets under consideration
+    :return: The object representing the stats
+
+    Note: The execution of this function requires the Flask app's context
+    """
+
+    ds_count, annexed_files_size, annexed_file_count = db.session.execute(
+        select(
+            func.count().label("ds_count"),
+            func.sum(q.c.annexed_files_in_wt_size).label("annexed_files_size"),
+            func.sum(q.c.annexed_files_in_wt_count).label("annexed_file_count"),
+        ).select_from(q)
+    ).one()
+
+    return AnnexDsCollectionStats(
+        ds_count=ds_count,
+        annexed_files_size=annexed_files_size,
+        annexed_file_count=annexed_file_count,
+    )
+
+
+def get_unique_dl_ds_collection_stats(base_q: Subquery) -> AnnexDsCollectionStats:
+    """
+    Get the stats of the subset of the collection of datasets that contains only
+    of Datalad datasets, considering datasets with the same `ds_id` as the same
+    dataset
+
+    :param base_q: The base query that specified the collection of datasets
+                   under consideration
+    :return: The object representing the stats
+
+    Note: The execution of this function requires the Flask app's context
+    """
+
+    grp_by_id_q = (
+        select(
+            base_q.c.ds_id,
+            func.max(base_q.c.annexed_files_in_wt_size).label(
+                "max_annexed_files_in_wt_size"
+            ),
+        )
+        .group_by(base_q.c.ds_id)
+        .subquery("grp_by_id_q")
+    )
+
+    grp_by_id_and_a_f_size_q = (
+        select(
+            RepoUrl.ds_id,
+            RepoUrl.annexed_files_in_wt_size,
+            func.max(RepoUrl.annexed_files_in_wt_count).label(
+                "annexed_files_in_wt_count"
+            ),
+        )
+        .join(
+            grp_by_id_q,
+            and_(
+                RepoUrl.ds_id == grp_by_id_q.c.ds_id,
+                or_(
+                    grp_by_id_q.c.max_annexed_files_in_wt_size.is_(None),
+                    RepoUrl.annexed_files_in_wt_size
+                    == grp_by_id_q.c.max_annexed_files_in_wt_size,
+                ),
+            ),
+        )
+        .group_by(RepoUrl.ds_id, RepoUrl.annexed_files_in_wt_size)
+        .subquery("grp_by_id_and_a_f_size_q")
+    )
+
+    return _get_annex_ds_collection_stats(grp_by_id_and_a_f_size_q)
+
+
+def get_dl_ds_collection_stats_with_dups(base_q: Subquery) -> AnnexDsCollectionStats:
+    """
+    Get the stats of the subset of the collection of datasets that contains only
+    of Datalad datasets, considering individual repos as a dataset regardless of
+    the value of `ds_id`.
+
+    :param base_q: The base query that specified the collection of datasets
+                   under consideration
+    :return: The object representing the stats
+
+    Note: The execution of this function requires the Flask app's context
+    """
+
+    # Select statement for getting all the Datalad datasets
+    dl_ds_q = select(base_q).filter(base_q.c.ds_id.is_not(None)).subquery("dl_ds_q")
+
+    return _get_annex_ds_collection_stats(dl_ds_q)
+
+
+def get_dl_ds_collection_stats(base_q: Subquery) -> DataladDsCollectionStats:
+    """
+    Get the stats of the subset of the collection of datasets that contains only
+    of Datalad datasets
+
+    :param base_q: The base query that specified the collection of datasets
+                   under consideration
+    :return: The object representing the stats
+
+    Note: The execution of this function requires the Flask app's context
+    """
+
+    return DataladDsCollectionStats(
+        unique_ds_stats=get_unique_dl_ds_collection_stats(base_q),
+        stats=get_dl_ds_collection_stats_with_dups(base_q),
+    )
+
+
+def get_pure_annex_ds_collection_stats(base_q: Subquery) -> AnnexDsCollectionStats:
+    """
+    Get the stats of the subset of the collection of datasets that contains only
+    of pure annex datasets, the annex datasets that are not Datalad datasets
+
+    :param base_q: The base query that specified the collection of datasets
+                   under consideration
+    :return: The object representing the stats
+
+    Note: The execution of this function requires the Flask app's context
+    """
+    # Select statement for getting all the pure annex datasets
+    pure_annex_ds_q = (
+        select(base_q)
+        .filter(and_(base_q.c.branches.has_key("git-annex"), base_q.c.ds_id.is_(None)))
+        .subquery("pure_annex_ds_q")
+    )
+
+    return _get_annex_ds_collection_stats(pure_annex_ds_q)
+
+
+def get_non_annex_ds_collection_stats(base_q: Subquery) -> NonAnnexDsCollectionStats:
+    """
+    Get the stats of the subset of the collection of datasets that contains only
+    of non-annex datasets
+
+    :param base_q: The base query that specified the collection of datasets
+                   under consideration
+    :return: The object representing the stats
+
+    Note: The execution of this function requires the Flask app's context
+    """
+    # Select statement for getting all the non-annex datasets
+    non_annex_ds_q = (
+        select(base_q)
+        .filter(not_(base_q.c.branches.has_key("git-annex")))
+        .subquery("non_annex_ds_q")
+    )
+
+    return NonAnnexDsCollectionStats(
+        ds_count=db.session.execute(
+            select(func.count().label("ds_count")).select_from(non_annex_ds_q)
+        ).scalar_one()
+    )
+
+
+def get_collection_stats(select_stmt: Select) -> CollectionStats:
+    """
+    Get the statistics of the collection of dataset URLs specified by the given select
+    statement
+
+    :param select_stmt: The given select statement
+    :return: The statistics of the collection of dataset URLs
+
+    Note: The execution of this function requires the Flask app's context
+    """
+
+    # Cache the result of the select statement to a temporary table
+    tmp_tb = cache_result_to_tmp_tb(select_stmt, "tmp_tb")
+
+    # base_q = select_stmt.subquery("base_q")
+    base_q = select(tmp_tb).subquery("base_q")
+
+    datalad_ds_stats = get_dl_ds_collection_stats(base_q)
+
+    # Total number of datasets, as individual repos, without any deduplication
+    ds_count = db.session.execute(
+        select(func.count().label("ds_count")).select_from(base_q)
+    ).scalar_one()
+
+    return CollectionStats(
+        datalad_ds_stats=datalad_ds_stats,
+        pure_annex_ds_stats=get_pure_annex_ds_collection_stats(base_q),
+        non_annex_ds_stats=get_non_annex_ds_collection_stats(base_q),
+        summary=StatsSummary(
+            unique_ds_count=datalad_ds_stats.unique_ds_stats.ds_count, ds_count=ds_count
+        ),
+    )
diff --git a/datalad_registry/blueprints/api/utils.py b/datalad_registry/blueprints/api/utils.py
index f8265727..41422e1d 100644
--- a/datalad_registry/blueprints/api/utils.py
+++ b/datalad_registry/blueprints/api/utils.py
@@ -3,7 +3,7 @@
 
 from flask import current_app, request
 
-from datalad_registry import OperationMode
+from datalad_registry.conf import OperationMode
 from datalad_registry.utils.flask_tools import json_resp_from_str
 
 from . import HTTPExceptionResp
diff --git a/datalad_registry/overview.py b/datalad_registry/overview.py
index f8c5915f..7aadcc39 100644
--- a/datalad_registry/overview.py
+++ b/datalad_registry/overview.py
@@ -4,8 +4,10 @@
 import logging
 
 from flask import Blueprint, render_template, request
+from humanize import intcomma
 from sqlalchemy import nullslast, select
 
+from datalad_registry.blueprints.api.dataset_urls.tools import get_collection_stats
 from datalad_registry.models import RepoUrl, db
 from datalad_registry.search import parse_query
 
@@ -28,11 +30,15 @@
 }
 
 
+# Register humanize.intcomma as a Jinja2 filter
+bp.add_app_template_filter(intcomma, "intcomma")
+
+
 @bp.get("/")
 def overview():  # No type hints due to mypy#7187.
     default_sort_scheme = "update-desc"
 
-    select_stmt = select(RepoUrl)
+    base_select_stmt = select(RepoUrl)
 
     # Search using query if provided.
     # ATM it is just a 'filter' on URL records, later might be more complex
@@ -46,25 +52,30 @@ def overview():  # No type hints due to mypy#7187.
         except Exception as e:
             search_error = str(e)
         else:
-            select_stmt = select_stmt.filter(criteria)
+            base_select_stmt = base_select_stmt.filter(criteria)
 
-    # Sort
-    select_stmt = select_stmt.group_by(RepoUrl)
+    # Decipher sorting scheme
     sort_by = request.args.get("sort", default_sort_scheme, type=str)
     if sort_by not in _SORT_ATTRS:
         lgr.debug("Ignoring unknown sort parameter: %s", sort_by)
         sort_by = default_sort_scheme
     col, sort_method = _SORT_ATTRS[sort_by]
-    select_stmt = select_stmt.order_by(
+
+    # Apply sorting
+    select_stmt = base_select_stmt.order_by(
         nullslast(getattr(getattr(RepoUrl, col), sort_method)())
     )
 
     # Paginate
     pagination = db.paginate(select_stmt)
 
+    # Gather stats of the returned collection of datasets
+    stats = get_collection_stats(base_select_stmt)
+
     return render_template(
         "overview.html",
         pagination=pagination,
+        stats=stats,
         sort_by=sort_by,
         search_query=query,
         search_error=search_error,
diff --git a/datalad_registry/static/main.css b/datalad_registry/static/main.css
index 3c24aedd..06ba9fc4 100644
--- a/datalad_registry/static/main.css
+++ b/datalad_registry/static/main.css
@@ -120,7 +120,7 @@ div#datalad-registry div.pagination {
 /* Modal Content */
 .modal-content {
     position: fixed;
-    bottom: 50%;
+    top: 10%;
     background-color: #fefefe;
     width: 100%;
     -webkit-animation-name: slideIn;
@@ -131,13 +131,25 @@ div#datalad-registry div.pagination {
 
 /* Add Animation */
 @-webkit-keyframes slideIn {
-    from {bottom: -300px; opacity: 0}
-    to {bottom: 50%; opacity: 1}
+    from {
+        top: 50%;
+        opacity: 0
+    }
+    to {
+        top: 10%;
+        opacity: 1
+    }
 }
 
 @keyframes slideIn {
-    from {bottom: -300px; opacity: 0}
-    to {bottom: 50%; opacity: 1}
+    from {
+        top: 50%;
+        opacity: 0
+    }
+    to {
+        top: 10%;
+        opacity: 1
+    }
 }
 
 @-webkit-keyframes fadeIn {
diff --git a/datalad_registry/templates/overview.html b/datalad_registry/templates/overview.html
index 75f621bb..45f255b0 100644
--- a/datalad_registry/templates/overview.html
+++ b/datalad_registry/templates/overview.html
@@ -27,6 +27,20 @@
   </div>
 {% endmacro %}
 
+{% macro render_annex_ds_collection_stats(annex_ds_col_stats) %}
+  <ul>
+    <li>Count: {{ annex_ds_col_stats.ds_count|intcomma }}</li>
+    {% if annex_ds_col_stats.annexed_file_count is not none %}
+      <li>Annexed file
+        count: {{ annex_ds_col_stats.annexed_file_count|intcomma }}</li>
+    {% endif %}
+    {% if annex_ds_col_stats.annexed_files_size is not none %}
+      <li>Annexed files
+        size: {{ annex_ds_col_stats.annexed_files_size|filesizeformat }} </li>
+    {% endif %}
+  </ul>
+{% endmacro %}
+
 <!DOCTYPE html>
 <html lang="en">
 <head>
@@ -59,14 +73,13 @@
         <input type='submit' value='Clear'/>
         </form>
     {%- endif %}
-    <button id="showQuerySyntax">Show search query syntax</button>
+    <button id="ShowQuerySyntax">Show search query syntax</button>
 
+    <!-- Syntax modal -->
     <div id="QuerySyntaxModal" class="modal">
-
-    <!-- Modal content -->
       <div class="modal-content">
         <div class="modal-header">
-          <span class="close">&times;</span>
+          <span id="CloseSyntax" class="close">&times;</span>
           <h2>Search query syntax</h2>
         </div>
         <div class="modal-body">
@@ -178,35 +191,99 @@ <h2>Search query syntax</h2>
     <div class="pager">
       {{ render_pagination_widget(pagination, '.overview') }}
     </div>
+
+
+    <div>
+      <span style="margin-right: 10px"># of annexed
+      files: {{ ((stats.datalad_ds_stats.stats.annexed_file_count if stats.datalad_ds_stats.stats.annexed_file_count else 0) +
+        (stats.pure_annex_ds_stats.annexed_file_count if stats.pure_annex_ds_stats.annexed_file_count else 0))|intcomma }}</span>
+      <span style="margin-right: 5px">Combined size of annexed
+        files: {{ ((stats.datalad_ds_stats.stats.annexed_files_size if stats.datalad_ds_stats.stats.annexed_files_size else 0) + (stats.pure_annex_ds_stats.annexed_files_size if stats.pure_annex_ds_stats.annexed_files_size else 0))|filesizeformat }}</span>
+
+      <!-- Stats Trigger Button -->
+      <button id="ShowStats">Show details</button>
+    </div>
+
+
+    <!-- Statistics modal -->
+    <div id="StatsModal" class="modal">
+      <div class="modal-content">
+        <div class="modal-header">
+          <span id="CloseStats" class="close">&times;</span>
+          <h2>Stats</h2>
+        </div>
+        <div id="stats" class="modal-body">
+          <ul>
+            <li>
+              <h3>DataLad datasets stats</h3>
+              <ul>
+                <li>
+                  <h4>Unique DataLad dataset stats</h4>
+                  {{ render_annex_ds_collection_stats(stats.datalad_ds_stats.unique_ds_stats) }}
+                </li>
+                <li>
+                  <h4>Stats without deduplication</h4>
+                  {{ render_annex_ds_collection_stats(stats.datalad_ds_stats.stats) }}
+                </li>
+              </ul>
+            </li>
+            <li>
+              <h3>Pure annex repositories stats</h3>
+              {{ render_annex_ds_collection_stats(stats.pure_annex_ds_stats) }}
+            </li>
+            <li>
+              <h3>Non-annex repositories stats</h3>
+              <ul>
+                <li>Count: {{ stats.non_annex_ds_stats.ds_count|intcomma }}</li>
+              </ul>
+            </li>
+            <li>
+              <h3>Summary</h3>
+              <ul>
+                <li>Unique dataset count: {{ stats.summary.unique_ds_count|intcomma }}</li>
+                <li>Total dataset count (without
+                  deduplication): {{ stats.summary.ds_count|intcomma }}</li>
+              </ul>
+            </li>
+          </ul>
+        </div>
+      </div>
+    </div>
   </div>
 </div>
 
 <script>
-// Get the modal
-const modal = document.getElementById("QuerySyntaxModal");
+    function setupModal(modalId, btnShowId, btnCloseId) {
+        const modal = document.getElementById(modalId);
+        const btnShow = document.getElementById(btnShowId);
+        const btnClose = document.getElementById(btnCloseId);
 
-// Get the button that opens the modal
-const btn = document.getElementById("showQuerySyntax");
+        // When the user clicks the button, open the modal
+        btnShow.onclick = function () {
+            modal.style.display = "block";
+        }
 
-// Get the <span> element that closes the modal
-const span = document.getElementsByClassName("close")[0];
+        // When the user clicks on <span> (x), close the modal
+        btnClose.onclick = function () {
+            modal.style.display = "none";
+        }
 
-// When the user clicks the button, open the modal
-btn.onclick = function() {
-  modal.style.display = "block";
-}
+        return modal;
+    }
 
-// When the user clicks on <span> (x), close the modal
-span.onclick = function() {
-  modal.style.display = "none";
-}
+    // Setup modals
+    const modals = [];
+    modals.push(setupModal('QuerySyntaxModal', 'ShowQuerySyntax', 'CloseSyntax'));
+    modals.push(setupModal('StatsModal', 'ShowStats', 'CloseStats'));
 
-// When the user clicks anywhere outside the modal, close it
-window.onclick = function(event) {
-  if (event.target === modal) {
-    modal.style.display = "none";
-  }
-}
+    // When the user clicks anywhere outside the modal, close it
+    window.onclick = function (event) {
+        modals.forEach(function (modal) {
+            if (event.target === modal) {
+                modal.style.display = "none";
+            }
+        });
+    }
 
 function span_copy() {
   // Find all span elements with the class 'query'
diff --git a/datalad_registry/tests/conftest.py b/datalad_registry/tests/conftest.py
index 00fefd81..410ba586 100644
--- a/datalad_registry/tests/conftest.py
+++ b/datalad_registry/tests/conftest.py
@@ -16,6 +16,8 @@
 from datalad_registry.models import RepoUrl, URLMetadata, db
 from datalad_registry.utils.datalad_tls import clone
 
+from .tools import populate_with_dataset_urls
+
 
 @pytest.fixture(scope="session")
 def set_test_env(tmp_path_factory):
@@ -259,11 +261,11 @@ def populate_with_2_dataset_urls(flask_app):
 
 
 @pytest.fixture
-def populate_with_dataset_urls(flask_app) -> list[str]:
+def populate_with_std_ds_urls(flask_app) -> list[str]:
     """
-    Populate the url table with a list of DatasetURLs.
+    Populate the `repo_url` table with a list of standard (typical) RepoUrl objects
 
-    Returns: The list of DatasetURLs that were added to the database
+    Returns: The list of URLs, expressed in `str`, that were added to the database
     """
 
     urls = [
@@ -319,17 +321,12 @@ def populate_with_dataset_urls(flask_app) -> list[str]:
         ),
     ]
 
-    with flask_app.app_context():
-        for url in urls:
-            db.session.add(url)
-        db.session.commit()
-
-        return [url.url for url in urls]
+    return populate_with_dataset_urls(urls, flask_app)
 
 
 @pytest.fixture
 def populate_with_url_metadata(
-    populate_with_dataset_urls,  # noqa: U100 (unused argument)
+    populate_with_std_ds_urls,  # noqa: U100 (unused argument)
     flask_app,
 ):
     """
diff --git a/datalad_registry/tests/test_blueprints/test_api/test_dataset_urls.py b/datalad_registry/tests/test_blueprints/test_api/test_dataset_urls.py
index 2a5b9387..9e22c6f1 100644
--- a/datalad_registry/tests/test_blueprints/test_api/test_dataset_urls.py
+++ b/datalad_registry/tests/test_blueprints/test_api/test_dataset_urls.py
@@ -7,14 +7,21 @@
 from datalad_registry.blueprints.api.dataset_urls import DatasetURLRespModel
 from datalad_registry.blueprints.api.dataset_urls.models import (
     DEFAULT_PAGE,
+    AnnexDsCollectionStats,
+    CollectionStats,
+    DataladDsCollectionStats,
     DatasetURLPage,
     MetadataReturnOption,
+    NonAnnexDsCollectionStats,
+    StatsSummary,
 )
 from datalad_registry.blueprints.api.url_metadata.models import (
     URLMetadataModel,
     URLMetadataRef,
 )
 from datalad_registry.conf import OperationMode
+from datalad_registry.models import RepoUrl
+from datalad_registry.tests.tools import populate_with_dataset_urls
 
 
 class TestDeclareDatasetURL:
@@ -119,7 +126,7 @@ def mock_commit(_scoped_session_obj):
                 "/api/v2/dataset-urls", json={"url": "https://www.example.com"}
             )
 
-    @pytest.mark.usefixtures("populate_with_dataset_urls")
+    @pytest.mark.usefixtures("populate_with_std_ds_urls")
     @pytest.mark.parametrize(
         "url, expected_mark_for_chk_delay_args",
         [
@@ -255,7 +262,7 @@ def test_valid_query_params(self, flask_client, query_params):
         resp = flask_client.get("/api/v2/dataset-urls", query_string=query_params)
         assert resp.status_code == 200
 
-    @pytest.mark.usefixtures("populate_with_dataset_urls")
+    @pytest.mark.usefixtures("populate_with_std_ds_urls")
     @pytest.mark.parametrize(
         "query_params, expected_output",
         [
@@ -398,17 +405,17 @@ def test_filter(self, flask_client, query_params, expected_output):
 
         ds_url_page = DatasetURLPage.parse_raw(resp.text)
 
-        assert ds_url_page.total == expected_out_count
         assert ds_url_page.cur_pg_num == DEFAULT_PAGE
         assert ds_url_page.prev_pg is None
         assert ds_url_page.next_pg is None
         assert YURL(ds_url_page.first_pg).query["page"] == "1"
         assert YURL(ds_url_page.last_pg).query["page"] == "1"
+        assert ds_url_page.collection_stats.summary.ds_count == expected_out_count
 
         # Check the collection of dataset URLs
         assert {i.url for i in ds_url_page.dataset_urls} == expected_output
 
-    @pytest.mark.usefixtures("populate_with_dataset_urls")
+    @pytest.mark.usefixtures("populate_with_std_ds_urls")
     @pytest.mark.parametrize(
         "query_params",
         [
@@ -494,7 +501,7 @@ def test_metadata_return(self, metadata_ret_opt, flask_client):
 
                 assert all(type(m) is metadata_ret_type for m in url.metadata)
 
-    def test_pagination(self, populate_with_dataset_urls, flask_client):
+    def test_pagination(self, populate_with_std_ds_urls, flask_client):
         """
         Test the pagination of the results
         """
@@ -510,11 +517,11 @@ def test_pagination(self, populate_with_dataset_urls, flask_client):
         resp_json = resp.json
         ds_url_pg = DatasetURLPage.parse_obj(resp_json)
 
-        assert ds_url_pg.total == 4
         assert ds_url_pg.cur_pg_num == 1
         assert "prev_pg" not in resp_json
         assert ds_url_pg.prev_pg is None
         assert ds_url_pg.next_pg is not None
+        assert ds_url_pg.collection_stats.summary.ds_count == 4
 
         next_pg_lk, first_pg_lk, last_pg_lk = (
             YURL(pg)
@@ -548,11 +555,11 @@ def test_pagination(self, populate_with_dataset_urls, flask_client):
         resp_json = resp.json
         ds_url_pg = DatasetURLPage.parse_obj(resp_json)
 
-        assert ds_url_pg.total == 4
         assert ds_url_pg.cur_pg_num == 2
         assert ds_url_pg.prev_pg is not None
         assert "next_pg" not in resp_json
         assert ds_url_pg.next_pg is None
+        assert ds_url_pg.collection_stats.summary.ds_count == 4
 
         prev_pg_lk, first_pg_lk, last_pg_lk = (
             YURL(pg)
@@ -578,9 +585,9 @@ def test_pagination(self, populate_with_dataset_urls, flask_client):
         for url in ds_url_pg.dataset_urls:
             ds_urls.add(str(url.url))
 
-        assert ds_urls == set(populate_with_dataset_urls)
+        assert ds_urls == set(populate_with_std_ds_urls)
 
-    @pytest.mark.usefixtures("populate_with_dataset_urls")
+    @pytest.mark.usefixtures("populate_with_std_ds_urls")
     @pytest.mark.parametrize(
         "query_params, expected_results_by_id_prefix",
         [
@@ -675,6 +682,242 @@ def test_ordering(self, query_params, expected_results_by_id_prefix, flask_clien
             == expected_results_by_id_prefix
         )
 
+    @pytest.mark.parametrize(
+        "query_params, expected_stats",
+        [
+            (
+                {},
+                CollectionStats(
+                    datalad_ds_stats=DataladDsCollectionStats(
+                        unique_ds_stats=AnnexDsCollectionStats(
+                            ds_count=3,
+                            annexed_files_size=400 + 1001,
+                            annexed_file_count=50 + 100 + 150,
+                        ),
+                        stats=AnnexDsCollectionStats(
+                            ds_count=6,
+                            annexed_files_size=1000 + 1001 + 400,
+                            annexed_file_count=120 + 50 + 100 + 120 + 150 + 130,
+                        ),
+                    ),
+                    pure_annex_ds_stats=AnnexDsCollectionStats(
+                        ds_count=1, annexed_files_size=600, annexed_file_count=100
+                    ),
+                    non_annex_ds_stats=NonAnnexDsCollectionStats(ds_count=1),
+                    summary=StatsSummary(unique_ds_count=3, ds_count=9),
+                ),
+            ),
+            (
+                {"search": "url:datalad"},
+                CollectionStats(
+                    datalad_ds_stats=DataladDsCollectionStats(
+                        unique_ds_stats=AnnexDsCollectionStats(
+                            ds_count=2,
+                            annexed_files_size=1000 + 400,
+                            annexed_file_count=120 + 50,
+                        ),
+                        stats=AnnexDsCollectionStats(
+                            ds_count=2,
+                            annexed_files_size=1000 + 400,
+                            annexed_file_count=120 + 50,
+                        ),
+                    ),
+                    pure_annex_ds_stats=AnnexDsCollectionStats(
+                        ds_count=0, annexed_files_size=None, annexed_file_count=None
+                    ),
+                    non_annex_ds_stats=NonAnnexDsCollectionStats(ds_count=0),
+                    summary=StatsSummary(unique_ds_count=2, ds_count=2),
+                ),
+            ),
+            (
+                {"search": "url:.org"},
+                CollectionStats(
+                    datalad_ds_stats=DataladDsCollectionStats(
+                        unique_ds_stats=AnnexDsCollectionStats(
+                            ds_count=2,
+                            annexed_files_size=1000 + 400,
+                            annexed_file_count=120 + 50,
+                        ),
+                        stats=AnnexDsCollectionStats(
+                            ds_count=2,
+                            annexed_files_size=1000 + 400,
+                            annexed_file_count=120 + 50,
+                        ),
+                    ),
+                    pure_annex_ds_stats=AnnexDsCollectionStats(
+                        ds_count=0, annexed_files_size=None, annexed_file_count=None
+                    ),
+                    non_annex_ds_stats=NonAnnexDsCollectionStats(ds_count=1),
+                    summary=StatsSummary(unique_ds_count=2, ds_count=4),
+                ),
+            ),
+            (
+                # === The case of an empty set of dataset URLs returned ===
+                {"search": "url:.tv"},
+                CollectionStats(
+                    datalad_ds_stats=DataladDsCollectionStats(
+                        unique_ds_stats=AnnexDsCollectionStats(
+                            ds_count=0,
+                            annexed_files_size=None,
+                            annexed_file_count=None,
+                        ),
+                        stats=AnnexDsCollectionStats(
+                            ds_count=0,
+                            annexed_files_size=None,
+                            annexed_file_count=None,
+                        ),
+                    ),
+                    pure_annex_ds_stats=AnnexDsCollectionStats(
+                        ds_count=0, annexed_files_size=None, annexed_file_count=None
+                    ),
+                    non_annex_ds_stats=NonAnnexDsCollectionStats(ds_count=0),
+                    summary=StatsSummary(unique_ds_count=0, ds_count=0),
+                ),
+            ),
+            (
+                {"search": "url:distribits.live"},
+                CollectionStats(
+                    datalad_ds_stats=DataladDsCollectionStats(
+                        unique_ds_stats=AnnexDsCollectionStats(
+                            ds_count=2,
+                            annexed_files_size=1001,
+                            annexed_file_count=100 + 150,
+                        ),
+                        stats=AnnexDsCollectionStats(
+                            ds_count=4,
+                            annexed_files_size=1001,
+                            annexed_file_count=100 + 120 + 150 + 130,
+                        ),
+                    ),
+                    pure_annex_ds_stats=AnnexDsCollectionStats(
+                        ds_count=0, annexed_files_size=None, annexed_file_count=None
+                    ),
+                    non_annex_ds_stats=NonAnnexDsCollectionStats(ds_count=0),
+                    summary=StatsSummary(unique_ds_count=2, ds_count=4),
+                ),
+            ),
+        ],
+    )
+    def test_stats(self, query_params, expected_stats, flask_app, flask_client):
+        """
+        Test the compilation of stats regarding the returned dataset URLs
+        """
+
+        # Populate the DB with dataset URLs suitable for testing the stats
+        urls = [
+            RepoUrl(
+                url="https://www.example.com",
+                ds_id=None,
+                annexed_files_in_wt_count=100,
+                annexed_files_in_wt_size=600,
+                branches={
+                    "git-annex": {
+                        "hexsha": "f21cff198ce84438bd60d459577401d7168fd6db",
+                        "last_commit_dt": "2022-11-18T19:18:23+00:00",
+                    }
+                },
+            ),
+            RepoUrl(
+                url="http://www.datalad.org",
+                ds_id="2a0b7b7b-a984-4c4a-844c-be3132291a7c",
+                annexed_files_in_wt_count=120,
+                annexed_files_in_wt_size=1000,
+                branches={
+                    "git-annex": {
+                        "hexsha": "f21cff198ce84438bd60d459577401d7168fd6ta",
+                        "last_commit_dt": "2022-11-18T19:18:23+00:00",
+                    }
+                },
+            ),
+            RepoUrl(
+                url="https://handbook.datalad.org",
+                ds_id="2b73b99e-59cc-4f35-833a-69c75ca5b0c5",
+                annexed_files_in_wt_count=50,
+                annexed_files_in_wt_size=400,
+                branches={
+                    "git-annex": {
+                        "hexsha": "f21cff198ce84438bd60d459577401d7168fd6cc",
+                        "last_commit_dt": "2022-11-18T19:18:23+00:00",
+                    }
+                },
+            ),
+            RepoUrl(
+                url="https://www.dandiarchive.org",
+                ds_id=None,
+                annexed_files_in_wt_count=100,
+                annexed_files_in_wt_size=300,
+            ),
+            RepoUrl(
+                url="https://distribits.live",
+                ds_id="2a0b7b7b-a984-4c4a-844c-be3132291a7c",
+                annexed_files_in_wt_count=100,
+                annexed_files_in_wt_size=1001,
+                branches={
+                    "git-annex": {
+                        "hexsha": "f21cff198ce84438bd60d459577401d7168fdaba",
+                        "last_commit_dt": "2022-11-18T19:18:23+00:00",
+                    }
+                },
+            ),
+            RepoUrl(
+                url="https://distribits.live/1",
+                ds_id="48185fb3-aa80-47b4-8ab1-1d7d9fc8b192",
+                annexed_files_in_wt_count=120,
+                annexed_files_in_wt_size=None,
+                branches={
+                    "git-annex": {
+                        "hexsha": "f21cff198ce84438bd60d459577401d7168fdaba",
+                        "last_commit_dt": "2022-11-18T19:18:23+00:00",
+                    }
+                },
+            ),
+            RepoUrl(
+                url="https://distribits.live/2",
+                ds_id="48185fb3-aa80-47b4-8ab1-1d7d9fc8b192",
+                annexed_files_in_wt_count=150,
+                annexed_files_in_wt_size=None,
+                branches={
+                    "git-annex": {
+                        "hexsha": "f21cff198ce84438bd60d459577401d7168fdaba",
+                        "last_commit_dt": "2022-11-18T19:18:23+00:00",
+                    }
+                },
+            ),
+            RepoUrl(
+                url="https://distribits.live/3",
+                ds_id="48185fb3-aa80-47b4-8ab1-1d7d9fc8b192",
+                annexed_files_in_wt_count=130,
+                annexed_files_in_wt_size=None,
+                branches={
+                    "git-annex": {
+                        "hexsha": "f21cff198ce84438bd60d459577401d7168fdaba",
+                        "last_commit_dt": "2022-11-18T19:18:23+00:00",
+                    }
+                },
+            ),
+            RepoUrl(
+                url="https://centerforopenneuroscience.org",
+                ds_id=None,
+                annexed_files_in_wt_count=None,
+                annexed_files_in_wt_size=None,
+                branches={
+                    "main": {
+                        "hexsha": "f21cff198ce84438bd60d459577401d7168fdaba",
+                        "last_commit_dt": "2022-11-18T19:18:23+00:00",
+                    },
+                    "dev": {
+                        "hexsha": "f21cff198ce84438bd60d459577401d7175fdaba",
+                        "last_commit_dt": "2022-11-18T19:18:23+00:00",
+                    },
+                },
+            ),
+        ]
+        populate_with_dataset_urls(urls, flask_app)
+
+        resp = flask_client.get("/api/v2/dataset-urls", query_string=query_params)
+
+        assert DatasetURLPage.parse_raw(resp.text).collection_stats == expected_stats
+
 
 @pytest.mark.usefixtures("populate_with_2_dataset_urls")
 class TestDatasetURL:
diff --git a/datalad_registry/tests/test_overview.py b/datalad_registry/tests/test_overview.py
index 3472ec65..2763f051 100644
--- a/datalad_registry/tests/test_overview.py
+++ b/datalad_registry/tests/test_overview.py
@@ -6,7 +6,7 @@
 
 
 class TestOverView:
-    @pytest.mark.usefixtures("populate_with_dataset_urls")
+    @pytest.mark.usefixtures("populate_with_std_ds_urls")
     @pytest.mark.parametrize(
         "sort_by, expected_order",
         [
@@ -143,7 +143,7 @@ def test_sorting(
 
         assert url_list == expected_order
 
-    @pytest.mark.usefixtures("populate_with_dataset_urls")
+    @pytest.mark.usefixtures("populate_with_std_ds_urls")
     @pytest.mark.parametrize(
         "search_query, expected_results",
         [
@@ -180,7 +180,7 @@ def test_search_with_valid_query(
 
         assert url_list == expected_results
 
-    @pytest.mark.usefixtures("populate_with_dataset_urls")
+    @pytest.mark.usefixtures("populate_with_std_ds_urls")
     @pytest.mark.parametrize(
         "search_query, err_msg_prefix",
         [
@@ -206,7 +206,7 @@ def test_search_with_invalid_query(
         assert (error_span := soup.find("span", class_="error"))
         assert error_span.text.startswith(f"ERROR: {err_msg_prefix}")
 
-    def test_pagination(self, populate_with_dataset_urls, flask_client):
+    def test_pagination(self, populate_with_std_ds_urls, flask_client):
         """
         Test pagination in Web UI
         """
@@ -272,7 +272,7 @@ def test_pagination(self, populate_with_dataset_urls, flask_client):
         assert page_1_link.query["per_page"] == "2"
         assert page_1_link.query["sort"] == "update-desc"
 
-        assert ds_urls == set(populate_with_dataset_urls)
+        assert ds_urls == set(populate_with_std_ds_urls)
 
     @pytest.mark.usefixtures("populate_with_url_metadata")
     def test_metadata(self, flask_client):
diff --git a/datalad_registry/tests/test_search.py b/datalad_registry/tests/test_search.py
index 137e276f..39f85ec1 100644
--- a/datalad_registry/tests/test_search.py
+++ b/datalad_registry/tests/test_search.py
@@ -12,7 +12,7 @@
 
 @pytest.fixture
 def populate_with_url_metadata_for_search(
-    populate_with_dataset_urls,  # noqa: U100 (unused argument)
+    populate_with_std_ds_urls,  # noqa: U100 (unused argument)
     flask_app,
 ):
     """
diff --git a/datalad_registry/tests/test_tasks/test_chk_url_to_update.py b/datalad_registry/tests/test_tasks/test_chk_url_to_update.py
index 525cc0ff..ea351912 100644
--- a/datalad_registry/tests/test_tasks/test_chk_url_to_update.py
+++ b/datalad_registry/tests/test_tasks/test_chk_url_to_update.py
@@ -13,7 +13,7 @@
 # and the db and the cache are clean
 @pytest.mark.usefixtures("flask_app")
 class TestChkUrlToUpdate:
-    @pytest.mark.usefixtures("populate_with_dataset_urls")
+    @pytest.mark.usefixtures("populate_with_std_ds_urls")
     @pytest.mark.parametrize("invalid_url_id", [-1, 0, 5, 10])
     def test_repo_url_not_found(self, invalid_url_id):
         """
@@ -21,7 +21,7 @@ def test_repo_url_not_found(self, invalid_url_id):
         """
         assert chk_url_to_update(invalid_url_id, None) is ChkUrlStatus.ABORTED
 
-    @pytest.mark.usefixtures("populate_with_dataset_urls")
+    @pytest.mark.usefixtures("populate_with_std_ds_urls")
     @pytest.mark.parametrize(
         "url_id, initial_last_chk_dt",
         [
@@ -38,7 +38,7 @@ def test_chk_handled_by_another_process(self, url_id, initial_last_chk_dt):
         """
         assert chk_url_to_update(url_id, initial_last_chk_dt) is ChkUrlStatus.SKIPPED
 
-    @pytest.mark.usefixtures("populate_with_dataset_urls", "fix_datetime_now")
+    @pytest.mark.usefixtures("populate_with_std_ds_urls", "fix_datetime_now")
     @pytest.mark.parametrize(
         "url_id, initial_last_chk_dt, original_n_failed_chks, original_chk_req_dt",
         [
diff --git a/datalad_registry/tests/test_tasks/test_mark_for_chk.py b/datalad_registry/tests/test_tasks/test_mark_for_chk.py
index 079c5c63..696c029d 100644
--- a/datalad_registry/tests/test_tasks/test_mark_for_chk.py
+++ b/datalad_registry/tests/test_tasks/test_mark_for_chk.py
@@ -11,7 +11,7 @@
 # and the db and the cache are clean
 @pytest.mark.usefixtures("flask_app")
 class TestMarkForChk:
-    @pytest.mark.usefixtures("populate_with_dataset_urls")
+    @pytest.mark.usefixtures("populate_with_std_ds_urls")
     @pytest.mark.parametrize("url_id", [5, 42])
     def test_non_existing_url(self, url_id, mocker: MockerFixture):
         """
@@ -32,7 +32,7 @@ def now(cls, *args, **kwargs):
 
         datetime_mock.now.assert_not_called()
 
-    @pytest.mark.usefixtures("populate_with_dataset_urls")
+    @pytest.mark.usefixtures("populate_with_std_ds_urls")
     @pytest.mark.parametrize(
         "url_id, original_chk_req_dt, expecting_chk_req_dt_changed",
         [
diff --git a/datalad_registry/tests/tools.py b/datalad_registry/tests/tools.py
new file mode 100644
index 00000000..f07a9ca7
--- /dev/null
+++ b/datalad_registry/tests/tools.py
@@ -0,0 +1,22 @@
+# This file contains helper functions for testing purposes
+
+from flask import Flask
+
+from datalad_registry.models import RepoUrl, db
+
+
+def populate_with_dataset_urls(urls: list[RepoUrl], flask_app: Flask) -> list[str]:
+    """
+    Populate the `repo_url` table with a list of RepoUrl objects
+
+    :param urls: The list of RepoUrl objects to populate
+    :param flask_app: The Flask app instance which provides the context for
+                      database access
+    :return: The list of URLs, expressed in `str`, that were added to the database
+    """
+
+    with flask_app.app_context():
+        db.session.add_all(urls)
+        db.session.commit()
+
+        return [url.url for url in urls]
diff --git a/datalad_registry_client/tests/test_get_urls.py b/datalad_registry_client/tests/test_get_urls.py
index 5dc3e771..73184529 100644
--- a/datalad_registry_client/tests/test_get_urls.py
+++ b/datalad_registry_client/tests/test_get_urls.py
@@ -9,8 +9,13 @@
 from yarl import URL
 
 from datalad_registry.blueprints.api.dataset_urls.models import (
+    AnnexDsCollectionStats,
+    CollectionStats,
+    DataladDsCollectionStats,
     DatasetURLPage,
     DatasetURLRespModel,
+    NonAnnexDsCollectionStats,
+    StatsSummary,
 )
 from datalad_registry_client import DEFAULT_BASE_ENDPOINT
 
@@ -40,6 +45,22 @@ def __init__(self, status_code, text):
     metadata=[],
 )
 
+# Dummy stats objects
+annex_ds_collection_stats = AnnexDsCollectionStats(
+    ds_count=101, annexed_files_size=1900, annexed_file_count=42
+)
+dl_ds_collection_stats = DataladDsCollectionStats(
+    unique_ds_stats=annex_ds_collection_stats, stats=annex_ds_collection_stats
+)
+non_annex_ds_collection_stats = NonAnnexDsCollectionStats(ds_count=40)
+stats_summary = StatsSummary(unique_ds_count=101, ds_count=999)
+collection_stats = CollectionStats(
+    datalad_ds_stats=dl_ds_collection_stats,
+    pure_annex_ds_stats=annex_ds_collection_stats,
+    non_annex_ds_stats=non_annex_ds_collection_stats,
+    summary=stats_summary,
+)
+
 
 def test_register():
     """
@@ -79,7 +100,6 @@ def mock_get(s, url):  # noqa: U100 Unused argument
                 return MockResponse(
                     200,
                     DatasetURLPage(
-                        total=200,
                         cur_pg_num=1,
                         prev_pg="dummy",
                         next_pg=None,
@@ -91,6 +111,7 @@ def mock_get(s, url):  # noqa: U100 Unused argument
                                 url="https://www.example.com"
                             )
                         ],
+                        collection_stats=collection_stats,
                     ).json(exclude_none=True),
                 )
             else:
@@ -130,7 +151,6 @@ def mock_get(s, url):  # noqa: U100 Unused argument
                 return MockResponse(
                     200,
                     DatasetURLPage(
-                        total=100,
                         cur_pg_num=1,
                         prev_pg="dummy",
                         next_pg=None,
@@ -142,6 +162,7 @@ def mock_get(s, url):  # noqa: U100 Unused argument
                                 url="https://www.example.com"
                             )
                         ],
+                        collection_stats=collection_stats,
                     ).json(exclude_none=True),
                 )
             else:
@@ -170,12 +191,11 @@ def test_handle_successful_response(self, resp_pgs: list[list[str]], monkeypatch
         """
 
         def ds_url_pgs():
-            total = sum(len(pg) for pg in resp_pgs)
+            ds_count = sum(len(pg) for pg in resp_pgs)
 
             for i, pg in enumerate(resp_pgs):
                 # noinspection PyTypeChecker
                 yield DatasetURLPage(
-                    total=total,
                     cur_pg_num=i + 1,
                     prev_pg=None if i == 0 else "foo",
                     next_pg=None if i == len(resp_pgs) - 1 else "foo",
@@ -185,6 +205,12 @@ def ds_url_pgs():
                         DatasetURLRespModel(**dataset_url_resp_model_template, url=url)
                         for url in pg
                     ],
+                    collection_stats=CollectionStats(
+                        datalad_ds_stats=dl_ds_collection_stats,
+                        pure_annex_ds_stats=annex_ds_collection_stats,
+                        non_annex_ds_stats=non_annex_ds_collection_stats,
+                        summary=StatsSummary(unique_ds_count=101, ds_count=ds_count),
+                    ),
                 )
 
         ds_url_pgs_iter = ds_url_pgs()
@@ -238,7 +264,6 @@ def mock_responses():
                 yield MockResponse(
                     200,
                     DatasetURLPage(
-                        total=200,
                         cur_pg_num=i + 1,
                         prev_pg=None if i == 0 else "foo",
                         next_pg="bar",
@@ -250,6 +275,7 @@ def mock_responses():
                                 url="https://www.example.com"
                             )
                         ],
+                        collection_stats=collection_stats,
                     ).json(exclude_none=True),
                 )