diff --git a/swh/web/api/apiresponse.py b/swh/web/api/apiresponse.py
index 95c89687..5503c2b0 100644
--- a/swh/web/api/apiresponse.py
+++ b/swh/web/api/apiresponse.py
@@ -1,230 +1,230 @@
 # Copyright (C) 2017-2021  The Software Heritage developers
 # See the AUTHORS file at the top-level directory of this distribution
 # License: GNU Affero General Public License version 3, or any later version
 # See top-level LICENSE file for more information
 
 import json
 import logging
 import traceback
 from typing import Any, Dict, Optional
 
 from django.http import HttpResponse
 from django.shortcuts import render
 from django.utils.cache import add_never_cache_headers
 from django.utils.html import escape
 from rest_framework.exceptions import APIException
 from rest_framework.request import Request
 from rest_framework.response import Response
 from rest_framework.utils.encoders import JSONEncoder
 
 from swh.storage.exc import StorageAPIError, StorageDBError
 from swh.web.api import utils
 from swh.web.common.exc import (
     BadInputExc,
     ForbiddenExc,
     LargePayloadExc,
     NotFoundExc,
     sentry_capture_exception,
 )
 from swh.web.common.utils import gen_path_info, shorten_path
 from swh.web.config import get_config
 
 logger = logging.getLogger("django")
 
 
 def compute_link_header(rv: Dict[str, Any], options: Dict[str, Any]) -> Dict[str, Any]:
     """Add Link header in returned value results.
 
     Args:
         request: a DRF Request object
         rv (dict): dictionary with keys:
 
             - headers: potential headers with 'link-next' and 'link-prev'
               keys
             - results: containing the result to return
 
         options (dict): the initial dict to update with result if any
 
     Returns:
         dict: dictionary with optional keys 'link-next' and 'link-prev'
 
     """
     link_headers = []
 
     if "headers" not in rv:
         return {}
 
     rv_headers = rv["headers"]
 
     if "link-next" in rv_headers:
         link_headers.append('<%s>; rel="next"' % rv_headers["link-next"])
     if "link-prev" in rv_headers:
         link_headers.append('<%s>; rel="previous"' % rv_headers["link-prev"])
 
     if link_headers:
         link_header_str = ",".join(link_headers)
         headers = options.get("headers", {})
         headers.update({"Link": link_header_str})
         return headers
 
     return {}
 
 
 def filter_by_fields(request: Request, data: Dict[str, Any]) -> Dict[str, Any]:
     """Extract a request parameter 'fields' if it exists to permit the filtering on
     the data dict's keys.
 
     If such field is not provided, returns the data as is.
 
     """
     fields = request.query_params.get("fields")
     if fields:
         data = utils.filter_field_keys(data, set(fields.split(",")))
 
     return data
 
 
 def transform(rv: Dict[str, Any]) -> Dict[str, Any]:
     """Transform an eventual returned value with multiple layer of
     information with only what's necessary.
 
     If the returned value rv contains the 'results' key, this is the
     associated value which is returned.
 
     Otherwise, return the initial dict without the potential 'headers'
     key.
 
     """
     if "results" in rv:
         return rv["results"]
 
     if "headers" in rv:
         rv.pop("headers")
 
     return rv
 
 
 def make_api_response(
     request: Request,
     data: Dict[str, Any],
     doc_data: Optional[Dict[str, Any]] = None,
     options: Optional[Dict[str, Any]] = None,
 ) -> HttpResponse:
     """Generates an API response based on the requested mimetype.
 
     Args:
         request: a DRF Request object
         data: raw data to return in the API response
         doc_data: documentation data for HTML response
         options: optional data that can be used to generate the response
 
     Returns:
         a DRF Response a object
 
     """
     options = options or {}
     if data:
         options["headers"] = compute_link_header(data, options)
         data = transform(data)
         data = filter_by_fields(request, data)
     doc_data = doc_data or {}
     headers = {}
     if "headers" in options:
         doc_data["headers_data"] = options["headers"]
         headers = options["headers"]
 
     # get request status code
     doc_data["status_code"] = options.get("status", 200)
 
     accepted_media_type = getattr(request, "accepted_media_type", "application/json")
 
     # when requesting HTML, typically when browsing the API through its
     # documented views, we need to enrich the input data with documentation
     # and render the apidoc HTML template
     if accepted_media_type == "text/html":
         doc_data["response_data"] = data
         if data is not None:
             doc_data["response_data"] = json.dumps(
                 data, cls=JSONEncoder, sort_keys=True, indent=4, separators=(",", ": ")
             )
 
         doc_data["heading"] = shorten_path(str(request.path))
 
         # generate breadcrumbs data
         if "route" in doc_data:
             doc_data["endpoint_path"] = gen_path_info(doc_data["route"])
             for i in range(len(doc_data["endpoint_path"]) - 1):
                 doc_data["endpoint_path"][i]["path"] += "/doc/"
             if not doc_data["noargs"]:
                 doc_data["endpoint_path"][-1]["path"] += "/doc/"
 
         response = render(
-            request, "api/apidoc.html", doc_data, status=doc_data["status_code"]
+            request, "apidoc.html", doc_data, status=doc_data["status_code"]
         )
 
     # otherwise simply return the raw data and let DRF picks
     # the correct renderer (JSON or YAML)
     else:
         response = Response(
             data,
             headers=headers,
             content_type=accepted_media_type,
             status=doc_data["status_code"],
         )
 
     if getattr(request, "never_cache", False):
         add_never_cache_headers(response)
 
     return response
 
 
 def error_response(
     request: Request, exception: Exception, doc_data: Dict[str, Any]
 ) -> HttpResponse:
     """Private function to create a custom error response.
 
     Args:
         request: a DRF Request object
         error: the exception that caused the error
         doc_data: documentation data for HTML response
 
     """
     error_code = 500
     if isinstance(exception, BadInputExc):
         error_code = 400
     elif isinstance(exception, NotFoundExc):
         error_code = 404
     elif isinstance(exception, ForbiddenExc):
         error_code = 403
     elif isinstance(exception, LargePayloadExc):
         error_code = 413
     elif isinstance(exception, StorageDBError):
         error_code = 503
     elif isinstance(exception, StorageAPIError):
         error_code = 503
     elif isinstance(exception, APIException):
         error_code = exception.status_code
 
     error_opts = {"status": error_code}
     error_data = {
         "exception": exception.__class__.__name__,
         "reason": str(exception),
     }
 
     if getattr(request, "accepted_media_type", None) == "text/html":
         error_data["reason"] = escape(error_data["reason"])
 
     if get_config()["debug"]:
         error_data["traceback"] = traceback.format_exc()
         logger.debug(error_data["traceback"])
 
     return make_api_response(request, error_data, doc_data, options=error_opts)
 
 
 def error_response_handler(
     exc: Exception, context: Dict[str, Any]
 ) -> Optional[HttpResponse]:
     """Custom DRF exception handler used to generate API error responses."""
     sentry_capture_exception(exc)
     doc_data = getattr(exc, "doc_data", {})
     return error_response(context["request"], exc, doc_data)
diff --git a/swh/web/templates/api/endpoints.html b/swh/web/api/templates/api-endpoints.html
similarity index 100%
rename from swh/web/templates/api/endpoints.html
rename to swh/web/api/templates/api-endpoints.html
diff --git a/swh/web/templates/api/api.html b/swh/web/api/templates/api.html
similarity index 100%
rename from swh/web/templates/api/api.html
rename to swh/web/api/templates/api.html
diff --git a/swh/web/templates/api/apidoc.html b/swh/web/api/templates/apidoc.html
similarity index 100%
rename from swh/web/templates/api/apidoc.html
rename to swh/web/api/templates/apidoc.html
diff --git a/swh/web/api/views/utils.py b/swh/web/api/views/utils.py
index 783b1eb4..2196fb57 100644
--- a/swh/web/api/views/utils.py
+++ b/swh/web/api/views/utils.py
@@ -1,91 +1,91 @@
 # Copyright (C) 2015-2022  The Software Heritage developers
 # See the AUTHORS file at the top-level directory of this distribution
 # License: GNU Affero General Public License version 3, or any later version
 # See top-level LICENSE file for more information
 
 from types import GeneratorType
 from typing import Any, Callable, Dict, List, Optional, Tuple, Union
 
 from django.http import HttpRequest
 from rest_framework.decorators import api_view
 from rest_framework.request import Request
 from rest_framework.response import Response
 
 from swh.web.api.apiurls import APIUrls, api_route
 from swh.web.common.exc import NotFoundExc
 
 EnrichFunction = Callable[[Dict[str, str], Optional[HttpRequest]], Dict[str, str]]
 
 EnrichFunctionSearchResult = Callable[
     [Tuple[List[Dict[str, Any]], Optional[str]], Optional[HttpRequest]],
     Tuple[List[Dict[str, Any]], Optional[str]],
 ]
 
 
 def api_lookup(
     lookup_fn: Callable[..., Any],
     *args: Any,
     notfound_msg: Optional[str] = "Object not found",
     enrich_fn: Optional[Union[EnrichFunction, EnrichFunctionSearchResult]] = None,
     request: Optional[HttpRequest] = None,
     **kwargs: Any,
 ):
     r"""
     Capture a redundant behavior of:
         - looking up the backend with a criteria (be it an identifier or
           checksum) passed to the function lookup_fn
         - if nothing is found, raise an NotFoundExc exception with error
           message notfound_msg.
         - Otherwise if something is returned:
             - either as list, map or generator, map the enrich_fn function to
               it and return the resulting data structure as list.
             - either as dict and pass to enrich_fn and return the dict
               enriched.
 
     Args:
         - lookup_fn: function expects one criteria and optional supplementary
           \*args.
         - \*args: supplementary arguments to pass to lookup_fn.
         - notfound_msg: if nothing matching the criteria is found,
           raise NotFoundExc with this error message.
         - enrich_fn: Function to use to enrich the result returned by
           lookup_fn. Default to the identity function if not provided.
         - request: Input HTTP request that will be provided as parameter
           to enrich_fn.
 
 
     Raises:
         NotFoundExp or whatever `lookup_fn` raises.
 
     """
 
     def _enrich_fn_noop(x, request):
         return x
 
     if enrich_fn is None:
         enrich_fn = _enrich_fn_noop
     res = lookup_fn(*args, **kwargs)
     if res is None:
         raise NotFoundExc(notfound_msg)
     if isinstance(res, (list, GeneratorType)) or type(res) == map:
         return [enrich_fn(x, request) for x in res]
     return enrich_fn(res, request)
 
 
 @api_view(["GET", "HEAD"])
 def api_home(request: Request):
-    return Response({}, template_name="api/api.html")
+    return Response({}, template_name="api.html")
 
 
 APIUrls.add_url_pattern(r"^api/$", api_home, view_name="api-1-homepage")
 
 
 @api_route(r"/", "api-1-endpoints")
 def api_endpoints(request):
     """Display the list of opened api endpoints."""
     routes = APIUrls.get_app_endpoints().copy()
     for route, doc in routes.items():
         doc["doc_intro"] = doc["docstring"].split("\n\n")[0]
     # Return a list of routes with consistent ordering
     env = {"doc_routes": sorted(routes.items())}
-    return Response(env, template_name="api/endpoints.html")
+    return Response(env, template_name="api-endpoints.html")
diff --git a/swh/web/tests/api/test_apidoc.py b/swh/web/tests/api/test_apidoc.py
index ce950573..67c17972 100644
--- a/swh/web/tests/api/test_apidoc.py
+++ b/swh/web/tests/api/test_apidoc.py
@@ -1,487 +1,481 @@
 # Copyright (C) 2015-2019  The Software Heritage developers
 # See the AUTHORS file at the top-level directory of this distribution
 # License: GNU Affero General Public License version 3, or any later version
 # See top-level LICENSE file for more information
 
 import textwrap
 
 import pytest
 
 from rest_framework.response import Response
 
 from swh.storage.exc import StorageAPIError, StorageDBError
 from swh.web.api.apidoc import _parse_httpdomain_doc, api_doc
 from swh.web.api.apiurls import api_route
 from swh.web.common.exc import BadInputExc, ForbiddenExc, NotFoundExc
 from swh.web.common.utils import prettify_html, reverse
 from swh.web.tests.utils import check_api_get_responses, check_html_get_response
 
 _httpdomain_doc = """
 .. http:get:: /api/1/revision/(sha1_git)/
 
     Get information about a revision in the archive.
     Revisions are identified by **sha1** checksums, compatible with Git commit
     identifiers.
     See :func:`swh.model.git_objects.revision_git_object` in our data model
     module for details about how they are computed.
 
     :param string sha1_git: hexadecimal representation of the revision
         **sha1_git** identifier
 
     :reqheader Accept: the requested response content type,
         either ``application/json`` (default) or ``application/yaml``
     :resheader Content-Type: this depends on :http:header:`Accept` header
         of request
 
     :<json int n: sample input integer
     :<json string s: sample input string
     :<json array a: sample input array
 
     :>json object author: information about the author of the revision
     :>json object committer: information about the committer of the revision
     :>json string committer_date: RFC3339 representation of the commit date
     :>json string date: RFC3339 representation of the revision date
     :>json string directory: the unique identifier that revision points to
     :>json string directory_url: link to
         :http:get:`/api/1/directory/(sha1_git)/[(path)/]` to get information
         about the directory associated to the revision
     :>json string id: the revision unique identifier
     :>json boolean merge: whether or not the revision corresponds to a merge
         commit
     :>json string message: the message associated to the revision
     :>json array parents: the parents of the revision, i.e. the previous
         revisions that head directly to it, each entry of that array contains
         an unique parent revision identifier but also a link to
         :http:get:`/api/1/revision/(sha1_git)/` to get more information
         about it
     :>json string type: the type of the revision
 
     :statuscode 200: no error
     :statuscode 400: an invalid **sha1_git** value has been provided
     :statuscode 404: requested revision can not be found in the archive
 
     **Example:**
 
     .. parsed-literal::
 
         :swh_web_api:`revision/aafb16d69fd30ff58afdd69036a26047f3aebdc6/`
 """
 
 
 _exception_http_code = {
     BadInputExc: 400,
     ForbiddenExc: 403,
     NotFoundExc: 404,
     Exception: 500,
     StorageAPIError: 503,
     StorageDBError: 503,
 }
 
 
 def test_apidoc_nodoc_failure():
     with pytest.raises(Exception):
 
         @api_doc("/my/nodoc/url/")
         def apidoc_nodoc_tester(request, arga=0, argb=0):
             return Response(arga + argb)
 
 
 @api_route(r"/some/(?P<myarg>[0-9]+)/(?P<myotherarg>[0-9]+)/", "api-1-some-doc-route")
 @api_doc("/some/doc/route/")
 def apidoc_route(request, myarg, myotherarg, akw=0):
     """
     Sample doc
     """
     return {"result": int(myarg) + int(myotherarg) + akw}
 
 
 def test_apidoc_route_doc(client):
     url = reverse("api-1-some-doc-route-doc")
-    check_html_get_response(
-        client, url, status_code=200, template_used="api/apidoc.html"
-    )
+    check_html_get_response(client, url, status_code=200, template_used="apidoc.html")
 
 
 def test_apidoc_route_fn(api_client):
     url = reverse("api-1-some-doc-route", url_args={"myarg": 1, "myotherarg": 1})
     check_api_get_responses(api_client, url, status_code=200)
 
 
 @api_route(r"/test/error/(?P<exc_name>.+)/", "api-1-test-error")
 @api_doc("/test/error/")
 def apidoc_test_error_route(request, exc_name):
     """
     Sample doc
     """
     for e in _exception_http_code.keys():
         if e.__name__ == exc_name:
             raise e("Error")
 
 
 def test_apidoc_error(api_client):
     for exc, code in _exception_http_code.items():
         url = reverse("api-1-test-error", url_args={"exc_name": exc.__name__})
         check_api_get_responses(api_client, url, status_code=code)
 
 
 @api_route(
     r"/some/full/(?P<myarg>[0-9]+)/(?P<myotherarg>[0-9]+)/",
     "api-1-some-complete-doc-route",
 )
 @api_doc("/some/complete/doc/route/")
 def apidoc_full_stack(request, myarg, myotherarg, akw=0):
     """
     Sample doc
     """
     return {"result": int(myarg) + int(myotherarg) + akw}
 
 
 def test_apidoc_full_stack_doc(client):
     url = reverse("api-1-some-complete-doc-route-doc")
-    check_html_get_response(
-        client, url, status_code=200, template_used="api/apidoc.html"
-    )
+    check_html_get_response(client, url, status_code=200, template_used="apidoc.html")
 
 
 def test_apidoc_full_stack_fn(api_client):
     url = reverse(
         "api-1-some-complete-doc-route", url_args={"myarg": 1, "myotherarg": 1}
     )
     check_api_get_responses(api_client, url, status_code=200)
 
 
 @api_route(r"/test/post/only/", "api-1-test-post-only", methods=["POST"])
 @api_doc("/test/post/only/")
 def apidoc_test_post_only(request, exc_name):
     """
     Sample doc
     """
     return {"result": "some data"}
 
 
 def test_apidoc_post_only(client):
     # a dedicated view accepting GET requests should have
     # been created to display the HTML documentation
     url = reverse("api-1-test-post-only-doc")
-    check_html_get_response(
-        client, url, status_code=200, template_used="api/apidoc.html"
-    )
+    check_html_get_response(client, url, status_code=200, template_used="apidoc.html")
 
 
 def test_api_doc_parse_httpdomain():
     doc_data = {
         "description": "",
         "urls": [],
         "args": [],
         "params": [],
         "resheaders": [],
         "reqheaders": [],
         "input_type": "",
         "inputs": [],
         "return_type": "",
         "returns": [],
         "status_codes": [],
         "examples": [],
     }
 
     _parse_httpdomain_doc(_httpdomain_doc, doc_data)
 
     expected_urls = [
         {
             "rule": "/api/1/revision/ **\\(sha1_git\\)** /",
             "methods": ["GET", "HEAD", "OPTIONS"],
         }
     ]
 
     assert "urls" in doc_data
     assert doc_data["urls"] == expected_urls
 
     expected_description = (
         "Get information about a revision in the archive. "
         "Revisions are identified by **sha1** checksums, "
         "compatible with Git commit identifiers. See "
         "**swh.model.git_objects.revision_git_object** in "
         "our data model module for details about how they "
         "are computed."
     )
 
     assert "description" in doc_data
     assert doc_data["description"] == expected_description
 
     expected_args = [
         {
             "name": "sha1_git",
             "type": "string",
             "doc": (
                 "hexadecimal representation of the revision " "**sha1_git** identifier"
             ),
         }
     ]
 
     assert "args" in doc_data
     assert doc_data["args"] == expected_args
 
     expected_params = []
     assert "params" in doc_data
     assert doc_data["params"] == expected_params
 
     expected_reqheaders = [
         {
             "doc": (
                 "the requested response content type, either "
                 "``application/json`` (default) or ``application/yaml``"
             ),
             "name": "Accept",
         }
     ]
 
     assert "reqheaders" in doc_data
     assert doc_data["reqheaders"] == expected_reqheaders
 
     expected_resheaders = [
         {"doc": "this depends on **Accept** header of request", "name": "Content-Type"}
     ]
 
     assert "resheaders" in doc_data
     assert doc_data["resheaders"] == expected_resheaders
 
     expected_statuscodes = [
         {"code": "200", "doc": "no error"},
         {"code": "400", "doc": "an invalid **sha1_git** value has been provided"},
         {"code": "404", "doc": "requested revision can not be found in the archive"},
     ]
 
     assert "status_codes" in doc_data
     assert doc_data["status_codes"] == expected_statuscodes
 
     expected_input_type = "object"
 
     assert "input_type" in doc_data
     assert doc_data["input_type"] == expected_input_type
 
     expected_inputs = [
         {"name": "n", "type": "int", "doc": "sample input integer"},
         {"name": "s", "type": "string", "doc": "sample input string"},
         {"name": "a", "type": "array", "doc": "sample input array"},
     ]
 
     assert "inputs" in doc_data
     assert doc_data["inputs"] == expected_inputs
 
     expected_return_type = "object"
 
     assert "return_type" in doc_data
     assert doc_data["return_type"] == expected_return_type
 
     expected_returns = [
         {
             "name": "author",
             "type": "object",
             "doc": "information about the author of the revision",
         },
         {
             "name": "committer",
             "type": "object",
             "doc": "information about the committer of the revision",
         },
         {
             "name": "committer_date",
             "type": "string",
             "doc": "RFC3339 representation of the commit date",
         },
         {
             "name": "date",
             "type": "string",
             "doc": "RFC3339 representation of the revision date",
         },
         {
             "name": "directory",
             "type": "string",
             "doc": "the unique identifier that revision points to",
         },
         {
             "name": "directory_url",
             "type": "string",
             "doc": (
                 "link to `/api/1/directory/ </api/1/directory/doc/>`_ "
                 "to get information about the directory associated to "
                 "the revision"
             ),
         },
         {"name": "id", "type": "string", "doc": "the revision unique identifier"},
         {
             "name": "merge",
             "type": "boolean",
             "doc": "whether or not the revision corresponds to a merge commit",
         },
         {
             "name": "message",
             "type": "string",
             "doc": "the message associated to the revision",
         },
         {
             "name": "parents",
             "type": "array",
             "doc": (
                 "the parents of the revision, i.e. the previous revisions "
                 "that head directly to it, each entry of that array "
                 "contains an unique parent revision identifier but also a "
                 "link to `/api/1/revision/ </api/1/revision/doc/>`_ "
                 "to get more information about it"
             ),
         },
         {"name": "type", "type": "string", "doc": "the type of the revision"},
     ]
 
     assert "returns" in doc_data
     assert doc_data["returns"] == expected_returns
 
     expected_examples = ["/api/1/revision/aafb16d69fd30ff58afdd69036a26047f3aebdc6/"]
 
     assert "examples" in doc_data
     assert doc_data["examples"] == expected_examples
 
 
 @api_route(r"/post/endpoint/", "api-1-post-endpoint", methods=["POST"])
 @api_doc("/post/endpoint/")
 def apidoc_test_post_endpoint(request):
     """
     .. http:post:: /api/1/post/endpoint/
 
         Endpoint documentation
 
         :<jsonarr string -: Input array of SWHIDs
 
         :>json object <swhid>: an object whose keys are input SWHIDs
             and values objects with the following keys:
 
                 * **known (bool)**: whether the object was found
 
     """
     pass
 
 
 def test_apidoc_input_output_doc(client):
     url = reverse("api-1-post-endpoint-doc")
     rv = check_html_get_response(
-        client, url, status_code=200, template_used="api/apidoc.html"
+        client, url, status_code=200, template_used="apidoc.html"
     )
 
     input_html_doc = textwrap.indent(
         (
             '<dl class="row">\n'
             ' <dt class="col col-md-2 text-right">\n'
             "  array\n"
             " </dt>\n"
             ' <dd class="col col-md-9">\n'
             "  <p>\n"
             "   Input array of SWHIDs\n"
             "  </p>\n"
             " </dd>\n"
             "</dl>\n"
         ),
         " " * 7,
     )
 
     output_html_doc = textwrap.indent(
         (
             '<dl class="row">\n'
             ' <dt class="col col-md-2 text-right">\n'
             "  object\n"
             " </dt>\n"
             ' <dd class="col col-md-9">\n'
             "  <p>\n"
             "   an object containing the following keys:\n"
             "  </p>\n"
             '  <div class="swh-rst">\n'
             "   <blockquote>\n"
             "    <ul>\n"
             "     <li>\n"
             "      <p>\n"
             "       <strong>\n"
             "        &lt;swhid&gt; (object)\n"
             "       </strong>\n"
             "       :           an object whose keys are input SWHIDs"
             " and values objects with the following keys:\n"
             "      </p>\n"
             "      <blockquote>\n"
             '       <ul class="simple">\n'
             "        <li>\n"
             "         <p>\n"
             "          <strong>\n"
             "           known (bool)\n"
             "          </strong>\n"
             "          : whether the object was found\n"
             "         </p>\n"
             "        </li>\n"
             "       </ul>\n"
             "      </blockquote>\n"
             "     </li>\n"
             "    </ul>\n"
             "   </blockquote>\n"
             "  </div>\n"
             " </dd>\n"
             "</dl>\n"
         ),
         " " * 7,
     )
 
     html = prettify_html(rv.content)
 
     assert input_html_doc in html
     assert output_html_doc in html
 
 
 @api_route(r"/endpoint/links/in/doc/", "api-1-endpoint-links-in-doc")
 @api_doc("/endpoint/links/in/doc/")
 def apidoc_test_endpoint_with_links_in_doc(request):
     """
     .. http:get:: /api/1/post/endpoint/
 
         Endpoint documentation with links to
         :http:get:`/api/1/content/[(hash_type):](hash)/`,
         :http:get:`/api/1/directory/(sha1_git)/[(path)/]`
         and `archive <https://archive.softwareheritage.org>`_.
     """
     pass
 
 
 def test_apidoc_with_links(client):
     url = reverse("api-1-endpoint-links-in-doc")
     rv = check_html_get_response(
-        client, url, status_code=200, template_used="api/apidoc.html"
+        client, url, status_code=200, template_used="apidoc.html"
     )
 
     html = prettify_html(rv.content)
 
     first_link = textwrap.indent(
         (
             '<a class="reference external" href="/api/1/content/doc/">\n'
             " /api/1/content/\n"
             "</a>"
         ),
         " " * 9,
     )
 
     second_link = textwrap.indent(
         (
             '<a class="reference external" href="/api/1/directory/doc/">\n'
             " /api/1/directory/\n"
             "</a>"
         ),
         " " * 9,
     )
 
     third_link = textwrap.indent(
         (
             '<a class="reference external" '
             'href="https://archive.softwareheritage.org">\n'
             " archive\n"
             "</a>"
         ),
         " " * 9,
     )
 
     assert first_link in html
     assert second_link in html
     assert third_link in html