diff --git a/swh/web/api/views/add_forge_now.py b/swh/web/api/views/add_forge_now.py
index ebe08927..8e489cc5 100644
--- a/swh/web/api/views/add_forge_now.py
+++ b/swh/web/api/views/add_forge_now.py
@@ -1,226 +1,290 @@
 # Copyright (C) 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
 
 import json
 from typing import Union
 
 from django.core.exceptions import ObjectDoesNotExist
+from django.core.paginator import Paginator
 from django.db import transaction
 from django.forms import CharField, ModelForm
 from django.http import HttpResponseBadRequest
 from django.http.request import HttpRequest
 from django.http.response import HttpResponse, HttpResponseForbidden
 from rest_framework import serializers
 from rest_framework.request import Request
 from rest_framework.response import Response
 
 from swh.web.add_forge_now.models import Request as AddForgeRequest
 from swh.web.add_forge_now.models import RequestActorRole as AddForgeNowRequestActorRole
 from swh.web.add_forge_now.models import RequestHistory as AddForgeNowRequestHistory
 from swh.web.add_forge_now.models import RequestStatus as AddForgeNowRequestStatus
 from swh.web.api.apidoc import api_doc, format_docstring
 from swh.web.api.apiurls import api_route
 from swh.web.common.exc import BadInputExc
+from swh.web.common.utils import reverse
 
 MODERATOR_ROLE = "swh.web.add_forge_now.moderator"
 
 
 def _block_while_testing():
     """Replaced by tests to check concurrency behavior
     """
     pass
 
 
 class AddForgeNowRequestForm(ModelForm):
     class Meta:
         model = AddForgeRequest
         fields = (
             "forge_type",
             "forge_url",
             "forge_contact_email",
             "forge_contact_name",
             "forge_contact_comment",
         )
 
 
 class AddForgeNowRequestHistoryForm(ModelForm):
     new_status = CharField(max_length=200, required=False,)
 
     class Meta:
         model = AddForgeNowRequestHistory
         fields = ("text", "new_status")
 
 
 class AddForgeNowRequestSerializer(serializers.ModelSerializer):
     class Meta:
         model = AddForgeRequest
         fields = "__all__"
 
 
 class AddForgeNowRequestPublicSerializer(serializers.ModelSerializer):
     """Serializes AddForgeRequest without private fields.
     """
 
     class Meta:
         model = AddForgeRequest
         fields = ("forge_url", "forge_type", "status", "submission_date")
 
 
 @api_route(
     r"/add-forge/request/create", "api-1-add-forge-request-create", methods=["POST"],
 )
 @api_doc("/add-forge/request/create")
 @format_docstring()
 def api_add_forge_request_create(request: Union[HttpRequest, Request]) -> HttpResponse:
     """
     .. http:post:: /api/1/add-forge/request/create/
 
         Create a new request to add a forge to the list of those crawled regularly
         by Software Heritage.
 
         .. warning::
             That endpoint is not publicly available and requires authentication
             in order to be able to request it.
 
         {common_headers}
 
         :<json string forge_type: the type of forge
         :<json string forge_url: the base URL of the forge
         :<json string forge_contact_email: email of an administator of the forge to
             contact
         :<json string forge_contact_name: the name of the administrator
         :<json string forge_contact_comment: to explain how Software Heritage can
             verify forge administrator info are valid
 
         :statuscode 201: request successfully created
         :statuscode 400: missing or invalid field values
         :statuscode 403: user not authenticated
     """
     if not request.user.is_authenticated:
         return HttpResponseForbidden(
             "You must be authenticated to create a new add-forge request"
         )
 
     add_forge_request = AddForgeRequest()
 
     if isinstance(request, Request):
         # request submitted with request body in JSON (goes through DRF)
         form = AddForgeNowRequestForm(request.data, instance=add_forge_request)
     else:
         # request submitted with request body in form encoded format
         # (directly handled by Django)
         form = AddForgeNowRequestForm(request.POST, instance=add_forge_request)
 
     if form.errors:
         raise BadInputExc(json.dumps(form.errors))
 
     try:
         existing_request = AddForgeRequest.objects.get(
             forge_url=add_forge_request.forge_url
         )
     except ObjectDoesNotExist:
         pass
     else:
         return Response(
             f"Request for forge already exists (id {existing_request.id})",
             status=409,  # Conflict
         )
 
     add_forge_request.submitter_name = request.user.username
     add_forge_request.submitter_email = request.user.email
 
     form.save()
 
     data = AddForgeNowRequestSerializer(add_forge_request).data
 
     return Response(data=data, status=201)
 
 
 @api_route(
     r"/add-forge/request/(?P<id>[0-9]+)/update/",
     "api-1-add-forge-request-update",
     methods=["POST"],
 )
 @api_doc("/add-forge/request/update", tags=["hidden"])
 @format_docstring()
 @transaction.atomic
 def api_add_forge_request_update(
     request: Union[HttpRequest, Request], id: int
 ) -> HttpResponse:
     """
     .. http:post:: /api/1/add-forge/request/update/
 
         Update a request to add a forge to the list of those crawled regularly
         by Software Heritage.
 
         .. warning::
             That endpoint is not publicly available and requires authentication
             in order to be able to request it.
 
         {common_headers}
 
         :<json string text: comment about new request status
         :<json string new_status: the new request status
 
         :statuscode 200: request successfully updated
         :statuscode 400: missing or invalid field values
         :statuscode 403: user is not a moderator
     """
     if not request.user.is_authenticated:
         return HttpResponseForbidden(
             "You must be authenticated to update a new add-forge request"
         )
 
     if not request.user.has_perm(MODERATOR_ROLE):
         return HttpResponseForbidden("You are not a moderator")
 
     add_forge_request = (
         AddForgeRequest.objects.filter(id=id).select_for_update().first()
     )
 
     if add_forge_request is None:
         return HttpResponseBadRequest("Invalid request id")
 
     request_history = AddForgeNowRequestHistory()
     request_history.request = add_forge_request
 
     if isinstance(request, Request):
         # request submitted with request body in JSON (goes through DRF)
         form = AddForgeNowRequestHistoryForm(request.data, instance=request_history)
     else:
         # request submitted with request body in form encoded format
         # (directly handled by Django)
         form = AddForgeNowRequestHistoryForm(request.POST, instance=request_history)
 
     if form.errors:
         raise BadInputExc(json.dumps(form.errors))
 
     new_status_str = form["new_status"].value()
     if new_status_str is not None:
         new_status = AddForgeNowRequestStatus[new_status_str]
         current_status = AddForgeNowRequestStatus[add_forge_request.status]
         if new_status not in current_status.allowed_next_statuses():
             raise BadInputExc(
                 f"New request status {new_status} cannot be reached "
                 f"from current status {add_forge_request.status}"
             )
 
     _block_while_testing()
 
     request_history.actor = request.user.username
     request_history.actor_role = AddForgeNowRequestActorRole.MODERATOR.name
     form.save(commit=False)
 
     if request_history.new_status == "":
         request_history.new_status = None
 
     request_history.save()
 
     if request_history.new_status is not None:
         add_forge_request.status = request_history.new_status
         add_forge_request.save()
 
     data = AddForgeNowRequestSerializer(add_forge_request).data
     return Response(data=data, status=200)
+
+
+@api_route(
+    r"/add-forge/request/list", "api-1-add-forge-request-list", methods=["GET"],
+)
+@api_doc("/add-forge/request/list")
+@format_docstring()
+def api_add_forge_request_list(request: Union[HttpRequest, Request]):
+    """
+    .. http:get:: /api/1/add-forge/request/list/
+
+        List requests to add forges to the list of those crawled regularly
+        by Software Heritage.
+
+        {common_headers}
+        {resheader_link}
+
+        :query int page: optional page number
+        :query int per_page: optional number of elements per page (bounded to 1000)
+
+        :statuscode 200: always
+    """
+
+    add_forge_requests = AddForgeRequest.objects.order_by("-id")
+
+    if (
+        int(request.GET.get("user_requests_only", "0"))
+        and request.user.is_authenticated
+    ):
+        add_forge_requests = add_forge_requests.filter(
+            submitter_name=request.user.username
+        )
+
+    page_num = int(request.GET.get("page", 1))
+    per_page = int(request.GET.get("per_page", 10))
+    per_page = min(per_page, 1000)
+
+    paginator = Paginator(add_forge_requests, per_page)
+    page = paginator.page(page_num)
+
+    if request.user.has_perm(MODERATOR_ROLE):
+        results = AddForgeNowRequestSerializer(page.object_list, many=True).data
+    else:
+        results = AddForgeNowRequestPublicSerializer(page.object_list, many=True).data
+
+    response = {"results": results, "headers": {}}
+
+    if page.has_previous():
+        response["headers"]["link-prev"] = reverse(
+            "api-1-add-forge-request-list",
+            query_params={"page": page.previous_page_number(), "per_page": per_page},
+            request=request,
+        )
+
+    if page.has_next():
+        response["headers"]["link-next"] = reverse(
+            "api-1-add-forge-request-list",
+            query_params={"page": page.next_page_number(), "per_page": per_page},
+            request=request,
+        )
+
+    return response
diff --git a/swh/web/tests/api/views/test_add_forge_now.py b/swh/web/tests/api/views/test_add_forge_now.py
index 4f170b34..df06855f 100644
--- a/swh/web/tests/api/views/test_add_forge_now.py
+++ b/swh/web/tests/api/views/test_add_forge_now.py
@@ -1,267 +1,386 @@
 # Copyright (C) 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
 
 import datetime
 import threading
 import time
 from urllib.parse import urlencode
 
 import iso8601
 import pytest
 
 from swh.web.add_forge_now.models import Request
 from swh.web.api.views.add_forge_now import MODERATOR_ROLE
 from swh.web.common.utils import reverse
 from swh.web.tests.utils import (
+    check_api_get_responses,
     check_api_post_response,
     check_http_post_response,
     create_django_permission,
 )
 
 
 def test_add_forge_request_create_anonymous_user(api_client):
     url = reverse("api-1-add-forge-request-create")
     check_api_post_response(api_client, url, status_code=403)
 
 
 @pytest.mark.django_db
 def test_add_forge_request_create_empty(api_client, regular_user):
     api_client.force_login(regular_user)
     url = reverse("api-1-add-forge-request-create")
     resp = check_api_post_response(api_client, url, status_code=400)
     assert '"forge_type"' in resp.data["reason"]
 
 
 ADD_FORGE_DATA = {
     "forge_type": "gitlab",
     "forge_url": "https://gitlab.example.org",
     "forge_contact_email": "admin@gitlab.example.org",
     "forge_contact_name": "gitlab.example.org admin",
     "forge_contact_comment": "user marked as owner in forge members",
 }
 
 ADD_OTHER_FORGE_DATA = {
     "forge_type": "gitea",
     "forge_url": "https://gitea.example.org",
     "forge_contact_email": "admin@gitea.example.org",
     "forge_contact_name": "gitea.example.org admin",
     "forge_contact_comment": "user marked as owner in forge members",
 }
 
 
 @pytest.mark.django_db(transaction=True, reset_sequences=True)
 def test_add_forge_request_create_success(api_client, regular_user):
     api_client.force_login(regular_user)
     url = reverse("api-1-add-forge-request-create")
 
     date_before = datetime.datetime.now(tz=datetime.timezone.utc)
 
     resp = check_api_post_response(
         api_client, url, data=ADD_FORGE_DATA, status_code=201,
     )
 
     date_after = datetime.datetime.now(tz=datetime.timezone.utc)
 
     assert resp.data == {
         **ADD_FORGE_DATA,
         "id": 1,
         "status": "PENDING",
         "submission_date": resp.data["submission_date"],
         "submitter_name": regular_user.username,
         "submitter_email": regular_user.email,
     }
 
     assert date_before < iso8601.parse_date(resp.data["submission_date"]) < date_after
 
     request = Request.objects.all()[0]
 
     assert request.forge_url == ADD_FORGE_DATA["forge_url"]
     assert request.submitter_name == regular_user.username
 
 
 @pytest.mark.django_db(transaction=True, reset_sequences=True)
 def test_add_forge_request_create_success_form_encoded(client, regular_user):
     client.force_login(regular_user)
     url = reverse("api-1-add-forge-request-create")
 
     date_before = datetime.datetime.now(tz=datetime.timezone.utc)
 
     resp = check_http_post_response(
         client,
         url,
         request_content_type="application/x-www-form-urlencoded",
         data=urlencode(ADD_FORGE_DATA),
         status_code=201,
     )
 
     date_after = datetime.datetime.now(tz=datetime.timezone.utc)
 
     assert resp.data == {
         **ADD_FORGE_DATA,
         "id": 1,
         "status": "PENDING",
         "submission_date": resp.data["submission_date"],
         "submitter_name": regular_user.username,
         "submitter_email": regular_user.email,
     }
 
     assert date_before < iso8601.parse_date(resp.data["submission_date"]) < date_after
 
     request = Request.objects.all()[0]
 
     assert request.forge_url == ADD_FORGE_DATA["forge_url"]
     assert request.submitter_name == regular_user.username
 
 
 @pytest.mark.django_db(transaction=True, reset_sequences=True)
 def test_add_forge_request_create_duplicate(api_client, regular_user):
     api_client.force_login(regular_user)
     url = reverse("api-1-add-forge-request-create")
     check_api_post_response(
         api_client, url, data=ADD_FORGE_DATA, status_code=201,
     )
     check_api_post_response(
         api_client, url, data=ADD_FORGE_DATA, status_code=409,
     )
 
     requests = Request.objects.all()
     assert len(requests) == 1
 
 
 @pytest.fixture
 def moderator_user(regular_user2):
     regular_user2.user_permissions.add(create_django_permission(MODERATOR_ROLE))
     return regular_user2
 
 
 @pytest.mark.django_db(transaction=True, reset_sequences=True)
 def test_add_forge_request_update_anonymous_user(api_client):
     url = reverse("api-1-add-forge-request-update", url_args={"id": 1})
     check_api_post_response(api_client, url, status_code=403)
 
 
 @pytest.mark.django_db(transaction=True, reset_sequences=True)
 def test_add_forge_request_update_regular_user(api_client, regular_user):
     api_client.force_login(regular_user)
     url = reverse("api-1-add-forge-request-update", url_args={"id": 1})
     check_api_post_response(api_client, url, status_code=403)
 
 
 @pytest.mark.django_db(transaction=True, reset_sequences=True)
 def test_add_forge_request_update_non_existent(api_client, moderator_user):
     api_client.force_login(moderator_user)
     url = reverse("api-1-add-forge-request-update", url_args={"id": 1})
     check_api_post_response(api_client, url, status_code=400)
 
 
 def _create_add_forge_request(api_client, regular_user, data=ADD_FORGE_DATA):
     api_client.force_login(regular_user)
     url = reverse("api-1-add-forge-request-create")
     check_api_post_response(
         api_client, url, data=data, status_code=201,
     )
 
 
 @pytest.mark.django_db(transaction=True, reset_sequences=True)
 def test_add_forge_request_update_empty(api_client, regular_user, moderator_user):
     _create_add_forge_request(api_client, regular_user)
 
     api_client.force_login(moderator_user)
     url = reverse("api-1-add-forge-request-update", url_args={"id": 1})
     check_api_post_response(api_client, url, status_code=400)
 
 
 @pytest.mark.django_db(transaction=True, reset_sequences=True)
 def test_add_forge_request_update_missing_field(
     api_client, regular_user, moderator_user
 ):
     _create_add_forge_request(api_client, regular_user)
 
     api_client.force_login(moderator_user)
     url = reverse("api-1-add-forge-request-update", url_args={"id": 1})
     check_api_post_response(api_client, url, data={}, status_code=400)
     check_api_post_response(
         api_client, url, data={"new_status": "REJECTED"}, status_code=400
     )
 
 
 @pytest.mark.django_db(transaction=True, reset_sequences=True)
 def test_add_forge_request_update(api_client, regular_user, moderator_user):
     _create_add_forge_request(api_client, regular_user)
 
     api_client.force_login(moderator_user)
     url = reverse("api-1-add-forge-request-update", url_args={"id": 1})
 
     check_api_post_response(
         api_client, url, data={"text": "updating request"}, status_code=200
     )
 
     check_api_post_response(
         api_client,
         url,
         data={"new_status": "REJECTED", "text": "request rejected"},
         status_code=200,
     )
 
 
 @pytest.mark.django_db(transaction=True, reset_sequences=True)
 def test_add_forge_request_update_invalid_new_status(
     api_client, regular_user, moderator_user
 ):
     _create_add_forge_request(api_client, regular_user)
 
     api_client.force_login(moderator_user)
     url = reverse("api-1-add-forge-request-update", url_args={"id": 1})
     check_api_post_response(
         api_client,
         url,
         data={"new_status": "ACCEPTED", "text": "request accepted"},
         status_code=400,
     )
 
 
 @pytest.mark.django_db(transaction=True, reset_sequences=True)
 def test_add_forge_request_update_status_concurrent(
     api_client, regular_user, moderator_user, mocker
 ):
 
     _block_while_testing = mocker.patch(
         "swh.web.api.views.add_forge_now._block_while_testing"
     )
     _block_while_testing.side_effect = lambda: time.sleep(1)
 
     _create_add_forge_request(api_client, regular_user)
 
     api_client.force_login(moderator_user)
     url = reverse("api-1-add-forge-request-update", url_args={"id": 1})
 
     worker_ended = False
 
     def worker():
         nonlocal worker_ended
         check_api_post_response(
             api_client,
             url,
             data={"new_status": "WAITING_FOR_FEEDBACK", "text": "waiting for message"},
             status_code=200,
         )
         worker_ended = True
 
     # this thread will first modify the request status to WAITING_FOR_FEEDBACK
     thread = threading.Thread(target=worker)
     thread.start()
 
     # the other thread (slower) will attempt to modify the request status to REJECTED
     # but it will not be allowed as the first faster thread already modified it
     # and REJECTED state can not be reached from WAITING_FOR_FEEDBACK one
     time.sleep(0.5)
     check_api_post_response(
         api_client,
         url,
         data={"new_status": "REJECTED", "text": "request accepted"},
         status_code=400,
     )
     thread.join()
     assert worker_ended
+
+
+@pytest.mark.django_db(transaction=True, reset_sequences=True)
+def test_add_forge_request_list_anonymous(api_client, regular_user):
+    url = reverse("api-1-add-forge-request-list")
+
+    resp = check_api_get_responses(api_client, url, status_code=200)
+
+    assert resp.data == []
+
+    _create_add_forge_request(api_client, regular_user)
+
+    resp = check_api_get_responses(api_client, url, status_code=200)
+
+    add_forge_request = {
+        "forge_url": ADD_FORGE_DATA["forge_url"],
+        "forge_type": ADD_FORGE_DATA["forge_type"],
+        "status": "PENDING",
+        "submission_date": resp.data[0]["submission_date"],
+    }
+
+    assert resp.data == [add_forge_request]
+
+    _create_add_forge_request(api_client, regular_user, data=ADD_OTHER_FORGE_DATA)
+
+    resp = check_api_get_responses(api_client, url, status_code=200)
+
+    other_forge_request = {
+        "forge_url": ADD_OTHER_FORGE_DATA["forge_url"],
+        "forge_type": ADD_OTHER_FORGE_DATA["forge_type"],
+        "status": "PENDING",
+        "submission_date": resp.data[0]["submission_date"],
+    }
+
+    assert resp.data == [other_forge_request, add_forge_request]
+
+
+@pytest.mark.django_db(transaction=True, reset_sequences=True)
+def test_add_forge_request_list_moderator(api_client, regular_user, moderator_user):
+    url = reverse("api-1-add-forge-request-list")
+
+    _create_add_forge_request(api_client, regular_user)
+    _create_add_forge_request(api_client, regular_user, data=ADD_OTHER_FORGE_DATA)
+
+    api_client.force_login(moderator_user)
+    resp = check_api_get_responses(api_client, url, status_code=200)
+
+    add_forge_request = {
+        **ADD_FORGE_DATA,
+        "status": "PENDING",
+        "submission_date": resp.data[1]["submission_date"],
+        "submitter_name": regular_user.username,
+        "submitter_email": regular_user.email,
+        "id": 1,
+    }
+
+    other_forge_request = {
+        **ADD_OTHER_FORGE_DATA,
+        "status": "PENDING",
+        "submission_date": resp.data[0]["submission_date"],
+        "submitter_name": regular_user.username,
+        "submitter_email": regular_user.email,
+        "id": 2,
+    }
+
+    assert resp.data == [other_forge_request, add_forge_request]
+
+
+@pytest.mark.django_db(transaction=True, reset_sequences=True)
+def test_add_forge_request_list_pagination(
+    api_client, regular_user, api_request_factory
+):
+    _create_add_forge_request(api_client, regular_user)
+    _create_add_forge_request(api_client, regular_user, data=ADD_OTHER_FORGE_DATA)
+
+    url = reverse("api-1-add-forge-request-list", query_params={"per_page": 1})
+
+    resp = check_api_get_responses(api_client, url, 200)
+
+    assert len(resp.data) == 1
+
+    request = api_request_factory.get(url)
+
+    next_url = reverse(
+        "api-1-add-forge-request-list",
+        query_params={"page": 2, "per_page": 1},
+        request=request,
+    )
+
+    assert resp["Link"] == f'<{next_url}>; rel="next"'
+
+    resp = check_api_get_responses(api_client, next_url, 200)
+
+    assert len(resp.data) == 1
+
+    prev_url = reverse(
+        "api-1-add-forge-request-list",
+        query_params={"page": 1, "per_page": 1},
+        request=request,
+    )
+
+    assert resp["Link"] == f'<{prev_url}>; rel="previous"'
+
+
+@pytest.mark.django_db(transaction=True, reset_sequences=True)
+def test_add_forge_request_list_submitter_filtering(
+    api_client, regular_user, regular_user2
+):
+    _create_add_forge_request(api_client, regular_user)
+    _create_add_forge_request(api_client, regular_user2, data=ADD_OTHER_FORGE_DATA)
+
+    api_client.force_login(regular_user)
+    url = reverse(
+        "api-1-add-forge-request-list", query_params={"user_requests_only": 1}
+    )
+    resp = check_api_get_responses(api_client, url, status_code=200)
+
+    assert len(resp.data) == 1