diff --git a/swh/web/api/urls.py b/swh/web/api/urls.py
index 025afebc..831e16f1 100644
--- a/swh/web/api/urls.py
+++ b/swh/web/api/urls.py
@@ -1,21 +1,22 @@
 # Copyright (C) 2017-2020  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 swh.web.api.apiurls import APIUrls
+import swh.web.api.views.add_forge_now  # noqa
 import swh.web.api.views.content  # noqa
 import swh.web.api.views.directory  # noqa
 import swh.web.api.views.graph  # noqa
 import swh.web.api.views.identifiers  # noqa
 import swh.web.api.views.metadata  # noqa
 import swh.web.api.views.origin  # noqa
 import swh.web.api.views.origin_save  # noqa
 import swh.web.api.views.ping  # noqa
 import swh.web.api.views.release  # noqa
 import swh.web.api.views.revision  # noqa
 import swh.web.api.views.snapshot  # noqa
 import swh.web.api.views.stat  # noqa
 import swh.web.api.views.vault  # noqa
 
 urlpatterns = APIUrls.get_url_patterns()
diff --git a/swh/web/api/views/add_forge_now.py b/swh/web/api/views/add_forge_now.py
new file mode 100644
index 00000000..1a87302f
--- /dev/null
+++ b/swh/web/api/views/add_forge_now.py
@@ -0,0 +1,108 @@
+# 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.forms import ModelForm
+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.api.apidoc import api_doc, format_docstring
+from swh.web.api.apiurls import api_route
+from swh.web.common.exc import BadInputExc
+
+
+class AddForgeNowRequestForm(ModelForm):
+    class Meta:
+        model = AddForgeRequest
+        fields = (
+            "forge_type",
+            "forge_url",
+            "forge_contact_email",
+            "forge_contact_name",
+            "forge_contact_comment",
+        )
+
+
+class AddForgeNowRequestSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = AddForgeRequest
+        fields = "__all__"
+
+
+@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)
diff --git a/swh/web/tests/api/views/test_add_forge_now.py b/swh/web/tests/api/views/test_add_forge_now.py
new file mode 100644
index 00000000..6d9713e0
--- /dev/null
+++ b/swh/web/tests/api/views/test_add_forge_now.py
@@ -0,0 +1,117 @@
+# 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
+from urllib.parse import urlencode
+
+import iso8601
+import pytest
+
+from swh.web.add_forge_now.models import Request
+from swh.web.common.utils import reverse
+from swh.web.tests.utils import check_api_post_response, check_http_post_response
+
+
+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",
+}
+
+
+@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
diff --git a/swh/web/tests/utils.py b/swh/web/tests/utils.py
index e744cb2b..92413568 100644
--- a/swh/web/tests/utils.py
+++ b/swh/web/tests/utils.py
@@ -1,231 +1,233 @@
 # Copyright (C) 2020-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
 
 from typing import Any, Dict, Optional, cast
 
 from django.contrib.auth.models import Permission
 from django.contrib.contenttypes.models import ContentType
 from django.http import HttpResponse, StreamingHttpResponse
 from django.test.client import Client
 from rest_framework.response import Response
 from rest_framework.test import APIClient
 
 from swh.web.tests.django_asserts import assert_template_used
 
 
 def _assert_http_response(
     response: HttpResponse, status_code: int, content_type: str
 ) -> HttpResponse:
 
     if isinstance(response, Response):
         drf_response = cast(Response, response)
         error_context = (
             drf_response.data.pop("traceback")
             if isinstance(drf_response.data, dict) and "traceback" in drf_response.data
             else drf_response.data
         )
     elif isinstance(response, StreamingHttpResponse):
         error_context = getattr(response, "traceback", response.streaming_content)
     else:
         error_context = getattr(response, "traceback", response.content)
 
     assert response.status_code == status_code, error_context
     if content_type != "*/*":
         assert response["Content-Type"].startswith(content_type)
     return response
 
 
 def check_http_get_response(
     client: Client,
     url: str,
     status_code: int,
     content_type: str = "*/*",
     http_origin: Optional[str] = None,
     server_name: Optional[str] = None,
 ) -> HttpResponse:
     """Helper function to check HTTP response for a GET request.
 
     Args:
         client: Django test client
         url: URL to check response
         status_code: expected HTTP status code
         content_type: expected response content type
         http_origin: optional HTTP_ORIGIN header value
 
     Returns:
         The HTTP response
     """
     return _assert_http_response(
         response=client.get(
             url,
             HTTP_ACCEPT=content_type,
             HTTP_ORIGIN=http_origin,
             SERVER_NAME=server_name if server_name else "testserver",
         ),
         status_code=status_code,
         content_type=content_type,
     )
 
 
 def check_http_post_response(
     client: Client,
     url: str,
     status_code: int,
     content_type: str = "*/*",
+    request_content_type="application/json",
     data: Optional[Dict[str, Any]] = None,
     http_origin: Optional[str] = None,
 ) -> HttpResponse:
     """Helper function to check HTTP response for a POST request.
 
     Args:
         client: Django test client
         url: URL to check response
         status_code: expected HTTP status code
         content_type: expected response content type
+        request_content_type: content type of request body
         data: optional POST data
 
     Returns:
         The HTTP response
     """
     return _assert_http_response(
         response=client.post(
             url,
             data=data,
-            content_type="application/json",
+            content_type=request_content_type,
             HTTP_ACCEPT=content_type,
             HTTP_ORIGIN=http_origin,
         ),
         status_code=status_code,
         content_type=content_type,
     )
 
 
 def check_api_get_responses(
     api_client: APIClient, url: str, status_code: int
 ) -> Response:
     """Helper function to check Web API responses for GET requests
     for all accepted content types (JSON, YAML, HTML).
 
     Args:
         api_client: DRF test client
         url: Web API URL to check responses
         status_code: expected HTTP status code
 
     Returns:
         The Web API JSON response
     """
     # check JSON response
     response_json = check_http_get_response(
         api_client, url, status_code, content_type="application/json"
     )
 
     # check HTML response (API Web UI)
     check_http_get_response(api_client, url, status_code, content_type="text/html")
 
     # check YAML response
     check_http_get_response(
         api_client, url, status_code, content_type="application/yaml"
     )
 
     return cast(Response, response_json)
 
 
 def check_api_post_response(
     api_client: APIClient,
     url: str,
     status_code: int,
     content_type: str = "*/*",
     data: Optional[Dict[str, Any]] = None,
 ) -> HttpResponse:
     """Helper function to check Web API response for a POST request
     for all accepted content types.
 
     Args:
         api_client: DRF test client
         url: Web API URL to check response
         status_code: expected HTTP status code
 
     Returns:
         The HTTP response
     """
     return _assert_http_response(
         response=api_client.post(
             url, data=data, format="json", HTTP_ACCEPT=content_type,
         ),
         status_code=status_code,
         content_type=content_type,
     )
 
 
 def check_api_post_responses(
     api_client: APIClient,
     url: str,
     status_code: int,
     data: Optional[Dict[str, Any]] = None,
 ) -> Response:
     """Helper function to check Web API responses for POST requests
     for all accepted content types (JSON, YAML).
 
     Args:
         api_client: DRF test client
         url: Web API URL to check responses
         status_code: expected HTTP status code
 
     Returns:
         The Web API JSON response
     """
     # check JSON response
     response_json = check_api_post_response(
         api_client, url, status_code, content_type="application/json", data=data
     )
 
     # check YAML response
     check_api_post_response(
         api_client, url, status_code, content_type="application/yaml", data=data
     )
 
     return cast(Response, response_json)
 
 
 def check_html_get_response(
     client: Client, url: str, status_code: int, template_used: Optional[str] = None
 ) -> HttpResponse:
     """Helper function to check HTML responses for a GET request.
 
     Args:
         client: Django test client
         url: URL to check responses
         status_code: expected HTTP status code
         template_used: optional used Django template to check
 
     Returns:
         The HTML response
     """
     response = check_http_get_response(
         client, url, status_code, content_type="text/html"
     )
     if template_used is not None:
         assert_template_used(response, template_used)
     return response
 
 
 def create_django_permission(perm_name: str) -> Permission:
     """Create permission out of a permission name string
 
     Args:
         perm_name: Permission name (e.g. swh.web.api.throttling_exempted,
           swh.ambassador, ...)
 
     Returns:
         The persisted permission
 
     """
     perm_splitted = perm_name.split(".")
     app_label = ".".join(perm_splitted[:-1])
     perm_name = perm_splitted[-1]
     content_type = ContentType.objects.create(app_label=app_label, model="dummy")
     return Permission.objects.create(
         codename=perm_name, name=perm_name, content_type=content_type,
     )