diff --git a/backend/settings/settings.py b/backend/settings/settings.py
index a675226fbd..a366a1b795 100644
--- a/backend/settings/settings.py
+++ b/backend/settings/settings.py
@@ -313,6 +313,7 @@
         "api_video_post": "50/min",
         "api_users_me_export": "10/min",
         "api_export_comparisons": "10/min",
+        "api_rate_later_bulk_create": "20/day",
         # global throttle on account registrations and password reset
         "email": server_settings.get("THROTTLE_EMAIL_GLOBAL", "15/min"),
     },
diff --git a/backend/tournesol/serializers/rate_later.py b/backend/tournesol/serializers/rate_later.py
index 8ea7599389..ae9d898b22 100644
--- a/backend/tournesol/serializers/rate_later.py
+++ b/backend/tournesol/serializers/rate_later.py
@@ -1,4 +1,4 @@
-from django.db import IntegrityError
+from django.db import IntegrityError, transaction
 from django.utils.translation import gettext_lazy as _
 from rest_framework import serializers
 from rest_framework.serializers import ModelSerializer
@@ -16,6 +16,20 @@ class Meta:
         fields = ["created_at"]
 
 
+class RateLaterListSerializer(serializers.ListSerializer):
+    def create(self, validated_data):
+        result = []
+        for attrs in validated_data:
+            try:
+                with transaction.atomic():
+                    result.append(self.child.create(attrs))
+            except ConflictError:
+                # Ignore conflicts in bulk create
+                pass
+
+        return result
+
+
 class RateLaterSerializer(ModelSerializer):
     user = serializers.HiddenField(default=serializers.CurrentUserDefault())
     entity = RelatedEntitySerializer()
@@ -46,6 +60,7 @@ class Meta:
             "entity_contexts",
             "rate_later_metadata",
         ]
+        list_serializer_class = RateLaterListSerializer
 
     def create(self, validated_data):
         entity_id = validated_data.pop("entity")["pk"]
diff --git a/backend/tournesol/tests/test_api_rate_later.py b/backend/tournesol/tests/test_api_rate_later.py
index 36d1cdc726..ca87232129 100644
--- a/backend/tournesol/tests/test_api_rate_later.py
+++ b/backend/tournesol/tests/test_api_rate_later.py
@@ -14,6 +14,7 @@
 from tournesol.tests.factories.entity_poll_rating import EntityPollRatingFactory
 from tournesol.tests.factories.poll import PollFactory
 from tournesol.tests.factories.ratings import ContributorRatingFactory
+from tournesol.utils.constants import RATE_LATER_BULK_MAX_SIZE
 
 
 class RateLaterCommonMixinTestCase:
@@ -35,6 +36,7 @@ def setUp(self) -> None:
 
         self.poll = PollFactory()
         self.rate_later_base_url = f"/users/me/rate_later/{self.poll.name}/"
+        self.rate_later_bulk_base_url = f"/users/me/rate_later/{self.poll.name}/_bulk_create"
 
         self.entity_in_ratelater = VideoFactory()
 
@@ -273,6 +275,177 @@ def test_auth_404_create_invalid_poll(self) -> None:
         self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
 
 
+class RateLaterBulkCreateTestCase(RateLaterCommonMixinTestCase, TestCase):
+    """
+    TestCase of the `RateLaterBulkCreate` API.
+
+    The `RateLaterBulkCreate` API provides an endpoint to add multiple entities to the rate-later list.
+    """
+
+    _other_uid_not_in_db = "yt:n-oujbO9fdQ"
+
+    def test_anon_401_create(self) -> None:
+        """
+        An anonymous user cannot add entities to its rate-later list, even if
+        the poll exists.
+        """
+        data = [
+            {"entity": {"uid": self._uid_not_in_db}},
+            {"entity": {"uid": self._other_uid_not_in_db}},
+        ]
+        response = self.client.post(self.rate_later_bulk_base_url, data, format="json")
+        self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
+
+    def test_anon_401_create_invalid_poll(self) -> None:
+        """
+        An anonymous user cannot add entities to its rate-later list, even if
+        the poll doesn't exist.
+        """
+        data = [
+            {"entity": {"uid": self._uid_not_in_db}},
+            {"entity": {"uid": self._other_uid_not_in_db}},
+        ]
+        response = self.client.post(
+            f"/users/me/rate_later/{self._invalid_poll_name}/_bulk_create", data, format="json"
+        )
+        self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
+
+    @override_settings(YOUTUBE_API_KEY=None)
+    def test_auth_201_create(self) -> None:
+        """
+        An authenticated user can add entities to its rate-later list from a
+        specific poll, even if the entity doesn't exist in the database yet.
+        """
+        # A second poll ensures the create operation is poll specific.
+        other_poll = PollFactory()
+        initial_nbr = RateLater.objects.filter(poll=self.poll, user=self.user).count()
+
+        self.client.force_authenticate(self.user)
+        data = [
+            {"entity": {"uid": self._uid_not_in_db}},
+            {"entity": {"uid": self._other_uid_not_in_db}},
+        ]
+        response = self.client.post(self.rate_later_bulk_base_url, data, format="json")
+
+        self.assertEqual(response.status_code, status.HTTP_201_CREATED)
+        self.assertListEqual(
+            response.data,
+            [
+                {
+                    "entity": {
+                        "uid": self._uid_not_in_db,
+                        "type": "video",
+                        "metadata": ANY,
+                    },
+                    "entity_contexts": [],
+                    "collective_rating": None,
+                    "individual_rating": None,
+                    "rate_later_metadata": {"created_at": ANY},
+                },
+                {
+                    "entity": {
+                        "uid": self._other_uid_not_in_db,
+                        "type": "video",
+                        "metadata": ANY,
+                    },
+                    "entity_contexts": [],
+                    "collective_rating": None,
+                    "individual_rating": None,
+                    "rate_later_metadata": {"created_at": ANY},
+                },
+            ],
+        )
+
+        self.assertEqual(
+            RateLater.objects.filter(poll=self.poll, user=self.user).count(),
+            initial_nbr + 2,
+        )
+
+        # Rate-later items are saved per poll.
+        self.assertEqual(RateLater.objects.filter(poll=other_poll, user=self.user).count(), 0)
+
+    @override_settings(YOUTUBE_API_KEY=None)
+    def test_auth_201_create_two_times(self) -> None:
+        """
+        An authenticated user can request to add two times the same entity to a
+        rate-later list of a specific poll. In this case the duplicates are ignored.
+        """
+        other_poll = PollFactory()
+        initial_nbr = RateLater.objects.filter(poll=self.poll, user=self.user).count()
+
+        self.client.force_authenticate(self.user)
+        data = [
+            {"entity": {"uid": self.entity_in_ratelater.uid}},
+            {"entity": {"uid": self._uid_not_in_db}},
+        ]
+
+        response = self.client.post(self.rate_later_bulk_base_url, data, format="json")
+        self.assertEqual(response.status_code, status.HTTP_201_CREATED)
+
+        self.assertListEqual(
+            response.data,
+            [
+                {
+                    "entity": {
+                        "uid": self._uid_not_in_db,
+                        "type": "video",
+                        "metadata": ANY,
+                    },
+                    "entity_contexts": [],
+                    "collective_rating": None,
+                    "individual_rating": None,
+                    "rate_later_metadata": {"created_at": ANY},
+                },
+            ],
+        )
+        self.assertEqual(
+            RateLater.objects.filter(poll=self.poll, user=self.user).count(),
+            initial_nbr + 1,
+        )
+
+    @override_settings(YOUTUBE_API_KEY=None)
+    def test_create_size_limit(self) -> None:
+        """
+        An authenticated user can only add a limited number of entities.
+        """
+        self.client.force_authenticate(self.user)
+
+        limit = RATE_LATER_BULK_MAX_SIZE
+
+        initial_nbr = RateLater.objects.filter(poll=self.poll, user=self.user).count()
+        data = [{"entity": {"uid": "yt:entity1-{:03d}".format(n)}} for n in range(limit)]
+        response = self.client.post(self.rate_later_bulk_base_url, data, format="json")
+        self.assertEqual(response.status_code, status.HTTP_201_CREATED)
+        self.assertEqual(
+            RateLater.objects.filter(poll=self.poll, user=self.user).count(),
+            initial_nbr + 20,
+        )
+
+        initial_nbr = RateLater.objects.filter(poll=self.poll, user=self.user).count()
+        data = [{"entity": {"uid": "yt:entity2-{:03d}".format(n)}} for n in range(limit + 1)]
+        response = self.client.post(self.rate_later_bulk_base_url, data, format="json")
+        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
+        self.assertEqual(
+            RateLater.objects.filter(poll=self.poll, user=self.user).count(),
+            initial_nbr,
+        )
+
+    def test_auth_404_create_invalid_poll(self) -> None:
+        """
+        An authenticated user cannot add entities in a rate-later list from a
+        non-existing poll.
+        """
+        self.client.force_authenticate(self.user)
+        data = [
+            {"entity": {"uid": self._uid_not_in_db}},
+            {"entity": {"uid": self._other_uid_not_in_db}},
+        ]
+        response = self.client.post(
+            f"/users/me/rate_later/{self._invalid_poll_name}/_bulk_create", data, format="json"
+        )
+        self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
+
+
 class RateLaterDetailTestCase(RateLaterCommonMixinTestCase, TestCase):
     """
     TestCase of the `RateLaterDetail` API.
diff --git a/backend/tournesol/urls.py b/backend/tournesol/urls.py
index 048f54ce49..281c8bd0c1 100644
--- a/backend/tournesol/urls.py
+++ b/backend/tournesol/urls.py
@@ -38,7 +38,7 @@
 )
 from .views.previews.recommendations import get_preview_recommendations_redirect_params
 from .views.proof import ProofView
-from .views.rate_later import RateLaterDetail, RateLaterList
+from .views.rate_later import RateLaterBulkCreate, RateLaterDetail, RateLaterList
 from .views.ratings import (
     ContributorRatingDetail,
     ContributorRatingList,
@@ -113,6 +113,11 @@
         RateLaterList.as_view(),
         name="usersme_ratelater_list",
     ),
+    path(
+        "users/me/rate_later/<str:poll_name>/_bulk_create",
+        RateLaterBulkCreate.as_view(),
+        name="usersme_ratelater_bulk_create",
+    ),
     path(
         "users/me/rate_later/<str:poll_name>/<str:uid>/",
         RateLaterDetail.as_view(),
diff --git a/backend/tournesol/utils/constants.py b/backend/tournesol/utils/constants.py
index 057e4574cc..e91aa87181 100644
--- a/backend/tournesol/utils/constants.py
+++ b/backend/tournesol/utils/constants.py
@@ -17,3 +17,6 @@
 # Default weight for a criteria in the recommendations
 # FIXME: the default weight used by the front end is 50, not 10
 CRITERIA_DEFAULT_WEIGHT = 10
+
+# Maximum number of "rate later" entries that can be created in a bulk create request
+RATE_LATER_BULK_MAX_SIZE = 20
diff --git a/backend/tournesol/views/rate_later.py b/backend/tournesol/views/rate_later.py
index c36ceb1ea0..bca272e75a 100644
--- a/backend/tournesol/views/rate_later.py
+++ b/backend/tournesol/views/rate_later.py
@@ -9,6 +9,7 @@
 
 from tournesol.models import Entity, RateLater
 from tournesol.serializers.rate_later import RateLaterSerializer
+from tournesol.utils.constants import RATE_LATER_BULK_MAX_SIZE
 from tournesol.views.mixins.poll import PollScopedViewMixin
 
 
@@ -64,6 +65,38 @@ def perform_create(self, serializer):
         self.prefetch_entity(rate_later)
 
 
+@extend_schema_view(
+    post=extend_schema(
+        description="Add a multiple new entities to the logged user's rate-later list,"
+        " for a given poll.",
+        request=RateLaterSerializer(many=True),
+        responses={
+            201: RateLaterSerializer(many=True),
+        },
+    ),
+)
+class RateLaterBulkCreate(RateLaterQuerysetMixin, generics.CreateAPIView):
+    """
+    Create multiple rate-later entries at once.
+    Accepts an array of entities to be added to the rate-later list.
+    """
+
+    pagination_class = None
+    permission_classes = [IsAuthenticated]
+    throttle_scope = "api_rate_later_bulk_create"
+    serializer_class = RateLaterSerializer
+
+    def get_serializer(self, *args, **kwargs):
+        kwargs["many"] = True
+        kwargs["max_length"] = RATE_LATER_BULK_MAX_SIZE
+        return super().get_serializer(*args, **kwargs)
+
+    def perform_create(self, serializer):
+        rate_later_instances = serializer.save()
+        for rate_later in rate_later_instances:
+            self.prefetch_entity(rate_later)
+
+
 @extend_schema_view(
     get=extend_schema(description="Get an entity from the logged user's rate-later list."),
     delete=extend_schema(description="Delete an entity from the logged user's rate-later list."),
diff --git a/browser-extension/package.json b/browser-extension/package.json
index b3d5d631db..1a4b22707c 100644
--- a/browser-extension/package.json
+++ b/browser-extension/package.json
@@ -1,6 +1,6 @@
 {
   "name": "tournesol-extension",
-  "version": "3.7.0",
+  "version": "3.8.0",
   "license": "AGPL-3.0-or-later",
   "type": "module",
   "scripts": {
diff --git a/browser-extension/prepareExtension.js b/browser-extension/prepareExtension.js
index 3e0562b146..26d5a26586 100644
--- a/browser-extension/prepareExtension.js
+++ b/browser-extension/prepareExtension.js
@@ -119,10 +119,17 @@ const manifest = {
       run_at: 'document_end',
       all_frames: true,
     },
+    {
+      matches: ['https://*.youtube.com/feed/history'],
+      js: ['rateLaterHistory.js'],
+      css: ['rateLaterHistory.css'],
+      run_at: 'document_end',
+      all_frames: true,
+    },
     {
       matches: selectValue(env, {
         production: ['https://tournesol.app/*'],
-        'dev-env': ['http://localhost:3000/*'],
+        'dev-env': ['http://localhost/*'],
       }),
       js: ['fetchTournesolToken.js'],
       run_at: 'document_end',
diff --git a/browser-extension/src/_locales/en/messages.json b/browser-extension/src/_locales/en/messages.json
index 919daa4c19..2a1c49e2a9 100644
--- a/browser-extension/src/_locales/en/messages.json
+++ b/browser-extension/src/_locales/en/messages.json
@@ -14,6 +14,9 @@
   "menuPreferences": {
     "message": "Preferences"
   },
+  "menuRateLaterHistory": {
+    "message": "Import YouTube watch history"
+  },
   "recommendedByTournesol": {
     "message": "Recommended by Tournesol",
     "description": "Title of the main Tournesol container."
@@ -149,5 +152,53 @@
   "watchOnTournesolButtonLabel": {
     "message": "Watch on Tournesol",
     "description": "Label of the button displayed on video pages."
+  },
+  "rateLaterHistoryImportButton": {
+    "message": "Import history to Tournesol",
+    "description": "Label of the button displayed on the YouTube history page to import the history into your 'rate later' list."
+  },
+  "rateLaterHistoryStatusBoxTitle": {
+    "message": "Import of the YouTube history",
+    "description": "Title of the the rate later history import status box."
+  },
+  "rateLaterHistoryStatusBox429AlertP1" : {
+    "message": "The import is complete.",
+    "description": "First paragraph of the alert message, displayed when the daily import limit is reached."
+  },
+  "rateLaterHistoryStatusBox429AlertP2" : {
+    "message": "You have imported the maximum number of videos allowed today. You can start a new import in 24 hours.",
+    "description": "Second paragraph of the alert message, displayed when the daily import limit is reached."
+  },
+  "rateLaterHistoryStatusBoxMessage": {
+    "message": "Press Stop when the visible videos count doesn't increase anymore or when you think enough videos have been imported.",
+    "description": "Instructions displayed on the rate later history import status box."
+  },
+  "rateLaterHistoryVideoCount": {
+    "message": "Videos visible in history:",
+    "description": "Label showing the count of videos found in the YouTube history during import."
+  },
+  "rateLaterHistoryProcessedCount": {
+    "message": "Videos processed during the import:",
+    "description": "Label showing the count of videos processed by the import."
+  },
+  "rateLaterHistorySentCount": {
+    "message": "imported videos:",
+    "description": "Label showing the number of sent videos successfully imported in the rate later list (including those already present)."
+  },
+  "rateLaterHistorySkippedCount": {
+    "message": "skipped videos (previously imported):",
+    "description": "Label showing the number of videos that have NOT been sent to the Tournesol server, because they were present in the cache of previously imported videos."
+  },
+  "rateLaterHistoryFailureCount": {
+    "message": "failures:",
+    "description": "Label showing the count of sent videos that failed to be added to the rate later list, because of a server error."
+  },
+  "rateLaterHistoryCloseButtonLabel": {
+    "message": "Close",
+    "description": "Label of the button to close the import status box, when the import is over."
+  },
+  "rateLaterHistoryStopButtonLabel": {
+    "message": "Stop",
+    "description": "Label of the button to stop the YouTube history import process."
   }
 }
diff --git a/browser-extension/src/_locales/fr/messages.json b/browser-extension/src/_locales/fr/messages.json
index 75fdf3490e..c74c2e0433 100644
--- a/browser-extension/src/_locales/fr/messages.json
+++ b/browser-extension/src/_locales/fr/messages.json
@@ -14,6 +14,9 @@
   "menuPreferences": {
     "message": "Préférences"
   },
+  "menuRateLaterHistory": {
+    "message": "Importer l'historique YouTube"
+  },
   "recommendedByTournesol": {
     "message": "Recommandées par Tournesol",
     "description": "Titre du conteneur principal affichant les recommandations."
@@ -147,5 +150,53 @@
   "watchOnTournesolButtonLabel": {
     "message": "Regarder sur Tournesol",
     "description": "Label du bouton affiché sur les pages de vidéo."
+  },
+  "rateLaterHistoryImportButton": {
+    "message": "Importer l'historique dans Tournesol",
+    "description": "Label du  bouton affiché sur l'historique YouTube pour l'importer dans les vidéos à comparer plus tard."
+  },
+  "rateLaterHistoryStatusBoxTitle": {
+    "message": "Import de l'historique YouTube",
+    "description": "Titre de l'écran d'import de l'historique YouTube vers la liste des vidéos à comparer plus tard."
+  },
+  "rateLaterHistoryStatusBoxMessage": {
+    "message": "Appuyez sur Stop quand le nombre de vidéos visibles n'augmente plus ou que vous pensez que suffisamment de vidéos ont été importées.",
+    "description": "Instructions affichées sur l'écran d'import de l'historique YouTube vers la liste des vidéos à comparer plus tard."
+  },
+  "rateLaterHistoryStatusBox429AlertP1" : {
+    "message": "L'import est terminée.",
+    "description": "Premier paragraphe du message d'alerte, lorsque la limite d'import quotidienne est atteinte."
+  },
+  "rateLaterHistoryStatusBox429AlertP2" : {
+    "message": "Vous avez importé le nombre maximal de vidéos autorisé aujourd'hui. Vous pourrez lancer un nouvel import dans 24h.",
+    "description": "Deuxième paragraphe du message d'alerte, lorsque la limite d'import quotidienne est atteinte."
+  },
+  "rateLaterHistoryVideoCount": {
+    "message": "Vidéos visibles dans l'historique :",
+    "description": "Étiquette indiquant le nombre de vidéos trouvées dans l'historique YouTube pendant l'import."
+  },
+  "rateLaterHistoryProcessedCount": {
+    "message": "Vidéos traitées par le processus d'import :",
+    "description": "Étiquette indiquant le nombre total de vidéos traitées par le processus d'import."
+  },
+  "rateLaterHistorySentCount": {
+    "message": "vidéos importées :",
+    "description": "Étiquette indiquant le nombre de vidéos envoyées qui ont été ajoutées avec succès dans la liste à comparer plus tard (inclus les vidéos déjà présentes)."
+  },
+  "rateLaterHistorySkippedCount": {
+    "message": "vidéos évitées (importées précédemment) :",
+    "description": "Étiquette indiquant le nombre de vidéos non envoyées au serveur Tournesol, car déjà présentes dans le cache de vidéos précédement envoyées."
+  },
+  "rateLaterHistoryFailureCount": {
+    "message": "échecs :",
+    "description": "Étiquette indiquant le nombre de vidéos envoyées qui n'ont pas pu être ajoutées à la liste à comparer plus tard, à cause d'une erreur du serveur."
+  },
+  "rateLaterHistoryCloseButtonLabel": {
+    "message": "Fermer",
+    "description": "Texte du bouton permettant de fermer l'écran d'import, lorsque celui-ci est terminé."
+  },
+  "rateLaterHistoryStopButtonLabel": {
+    "message": "Stop",
+    "description": "Texte du bouton permettant d'arrêter le processus d'import de l'historique YouTube."
   }
 }
diff --git a/browser-extension/src/background.js b/browser-extension/src/background.js
index dac140e174..6e340affd8 100644
--- a/browser-extension/src/background.js
+++ b/browser-extension/src/background.js
@@ -1,5 +1,6 @@
 import {
   addRateLater,
+  addRateLaterBulk,
   alertOnCurrentTab,
   alertUseOnLinkToYoutube,
   fetchTournesolApi,
@@ -72,6 +73,12 @@ function getDateThreeWeeksAgo() {
 }
 
 chrome.runtime.onMessage.addListener((request, sender, sendResponse) => {
+  // Returns a boolean indicating whether the user is logged in on Tournesol from the extension's perspective
+  if (request.message === 'isLoggedIn') {
+    getAccessToken().then((token) => sendResponse(!!token));
+    return true;
+  }
+
   // Return the current access token in the chrome.storage.local.
   if (request.message === 'extAccessTokenNeeded') {
     getAccessToken().then((token) => sendResponse({ access_token: token }));
@@ -115,6 +122,11 @@ chrome.runtime.onMessage.addListener((request, sender, sendResponse) => {
     return true;
   }
 
+  if (request.message == 'addRateLaterBulk') {
+    addRateLaterBulk(request.videoIds).then(sendResponse);
+    return true;
+  }
+
   if (request.message.startsWith('getProof:')) {
     const keyword = request.message.split(':')[1];
 
diff --git a/browser-extension/src/browserAction/menu.html b/browser-extension/src/browserAction/menu.html
index eed0bb85f7..2c910dfca5 100644
--- a/browser-extension/src/browserAction/menu.html
+++ b/browser-extension/src/browserAction/menu.html
@@ -5,7 +5,7 @@
     <style>
       body {
         background: #ffc800;
-        width: 140px;
+        width: 200px;
         display: flex;
         flex-direction: column;
       }
@@ -60,5 +60,6 @@
     <button id="rate_later">Rate later</button>
     <button id="analysis">Analysis</button>
     <button id="preferences">Preferences</button>
+    <button id="rate_later_history">Rate later history</button>
   </body>
 </html>
diff --git a/browser-extension/src/browserAction/menu.js b/browser-extension/src/browserAction/menu.js
index b6e5116826..99e8c64bfc 100644
--- a/browser-extension/src/browserAction/menu.js
+++ b/browser-extension/src/browserAction/menu.js
@@ -108,6 +108,12 @@ function openOptionsPage() {
   chrome.runtime.openOptionsPage();
 }
 
+function rateLaterHistory() {
+  chrome.tabs.create({
+    url: 'https://www.youtube.com/feed/history',
+  });
+}
+
 /**
  * Create the action menu.
  */
@@ -117,15 +123,18 @@ document.addEventListener('DOMContentLoaded', function () {
   const rateLaterButton = document.getElementById('rate_later');
   const analysisButton = document.getElementById('analysis');
   const preferencesButton = document.getElementById('preferences');
+  const rateLaterHistoryButton = document.getElementById('rate_later_history');
 
   tournesolHomeLink.addEventListener('click', openTournesolHome);
   rateNowButton.addEventListener('click', rateNowAction);
   rateLaterButton.addEventListener('click', addToRateLaterAction);
   analysisButton.addEventListener('click', openAnalysisPageAction);
   preferencesButton.addEventListener('click', openOptionsPage);
+  rateLaterHistoryButton.addEventListener('click', rateLaterHistory);
 
   rateNowButton.textContent = i18n.getMessage('menuRateNow');
   rateLaterButton.textContent = i18n.getMessage('menuRateLater');
   analysisButton.textContent = i18n.getMessage('menuAnalysis');
   preferencesButton.textContent = i18n.getMessage('menuPreferences');
+  rateLaterHistoryButton.textContent = i18n.getMessage('menuRateLaterHistory');
 });
diff --git a/browser-extension/src/rateLaterHistory.css b/browser-extension/src/rateLaterHistory.css
new file mode 100644
index 0000000000..41fb8aeb27
--- /dev/null
+++ b/browser-extension/src/rateLaterHistory.css
@@ -0,0 +1,163 @@
+.tournesol-rate-later-history-button {
+  background: transparent;
+  border: none;
+  border-radius: 2px;
+  cursor: pointer;
+  font-family: 'Roboto', 'Noto', sans-serif;
+  display: flex;
+  align-items: center;
+  padding: 0 16px;
+  height: 36px;
+  font-size: 14px;
+  border-radius: 18px;
+  white-space: nowrap;
+  font-weight: 500;
+
+  color: #0f0f0f;
+  background: #ffc800;
+}
+.tournesol-rate-later-history-button:hover {
+  background: #b28c00;
+}
+.tournesol-rate-later-history-button:disabled {
+  opacity: 0.5;
+  cursor: default;
+  background: #ffc800;
+}
+
+#tournesol-rate-later-history-import-button {
+  justify-content: center;
+}
+
+#tournesol-rate-later-history-overlay {
+  z-index: 10000;
+  position: fixed;
+  top: 0;
+  right: 0;
+  bottom: 0;
+  left: 0;
+  background: rgba(127, 127, 127, 0.5);
+}
+
+body.tournesol-capturing-history {
+  overflow: hidden;
+}
+
+/* Hide thumbnails during the load to reduce network usage */
+body.tournesol-capturing-history ytd-thumbnail {
+  display: none;
+}
+
+#tournesol-rate-later-history-status-box {
+  position: absolute;
+  --width: min(500px, 60vw);
+  left: calc(50% - var(--width) / 2);
+  width: var(--width);
+  top: min(100px, calc(10vh));
+  max-height: 70vh;
+  overflow: auto;
+  background: #1282b2;
+  color: white;
+  padding: 16px;
+
+  border-radius: 8px;
+  box-shadow: 5px 3px 3px #222;
+
+  font-family: 'Roboto', 'Noto', sans-serif;
+  font-size: 14px;
+
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+}
+
+#tournesol-rate-later-history-status-box h3 {
+  margin-bottom: 8px;
+  text-decoration-line: underline;
+  text-decoration-color: rgb(255, 211, 51);
+  text-decoration-thickness: 0.4em;
+  text-decoration-skip-ink: none;
+  text-underline-offset: 0.2em;
+}
+
+#tournesol-rate-later-history-status-box .alert-box {
+  padding: 16px;
+  border-radius: 4px;
+
+  font-weight: 400;
+  line-height: 1.43;
+  letter-spacing: 0.02em;
+
+  color: rgb(30, 70, 32);
+  background-color: rgb(237, 247, 237);
+}
+
+#tournesol-rate-later-history-status-box .alert-box p:not(:first-child){
+  margin-top: 8px;
+}
+
+#tournesol-rate-later-history-status-box ul {
+  list-style-position: inside;
+}
+
+#tournesol-rate-later-history-status-box ul li:not(:first-child) {
+  margin-top: 6px;
+}
+
+#tournesol-rate-later-history-status-box .counter-section {
+  margin-top: 8px;
+}
+
+#tournesol-rate-later-history-status-box .count {
+  font-weight: bold;
+}
+
+#tournesol-rate-later-history-status-box #when-to-stop {
+  margin-top: 16px;
+}
+
+#tournesol-rate-later-history-stop-button {
+  justify-content: center;
+  margin-top: 16px;
+}
+
+.lds-dual-ring {
+  margin: 16px auto;
+}
+
+.lds-dual-ring,
+.lds-dual-ring:after {
+  box-sizing: border-box;
+}
+.lds-dual-ring {
+  display: inline-block;
+  width: 50px;
+  height: 50px;
+}
+.lds-dual-ring:after {
+  content: ' ';
+  display: block;
+  width: 32px;
+  height: 32px;
+  margin: 8px;
+  border-radius: 50%;
+  border: 4px solid currentColor;
+  border-color: currentColor transparent currentColor transparent;
+  animation: lds-dual-ring 1.2s linear infinite;
+}
+@keyframes lds-dual-ring {
+  0% {
+    transform: rotate(0deg);
+  }
+  100% {
+    transform: rotate(360deg);
+  }
+}
+
+.display-none {
+  display: none;
+}
+
+.visibility-hidden {
+  visibility: hidden;
+}
diff --git a/browser-extension/src/rateLaterHistory.js b/browser-extension/src/rateLaterHistory.js
new file mode 100644
index 0000000000..0357af4a3c
--- /dev/null
+++ b/browser-extension/src/rateLaterHistory.js
@@ -0,0 +1,439 @@
+const RATE_LATER_BULK_MAX_SIZE = 20;
+
+const onYoutubeReady = (callback) => {
+  /**
+   * Youtube doesnt completely load a video page, so content script doesn't
+   * launch correctly without these events.
+   *
+   * This part is called on connection for the first time on youtube.com/*
+   */
+  document.addEventListener('yt-navigate-finish', () => {
+    callback();
+  });
+
+  if (document.body) {
+    callback();
+  } else {
+    document.addEventListener('DOMContentLoaded', () => {
+      callback();
+    });
+  }
+};
+
+const addOverlay = () => {
+  document.body.classList.add('tournesol-capturing-history');
+
+  const overlay = document.createElement('div');
+  overlay.id = 'tournesol-rate-later-history-overlay';
+  document.body.append(overlay);
+
+  const statusBox = document.createElement('div');
+  statusBox.id = 'tournesol-rate-later-history-status-box';
+  overlay.append(statusBox);
+
+  const title = document.createElement('h3');
+  title.textContent = chrome.i18n.getMessage('rateLaterHistoryStatusBoxTitle');
+  statusBox.append(title);
+
+  const alertBox = document.createElement('div');
+  alertBox.classList.add('alert-box', 'display-none');
+  const alertBoxText1 = document.createElement('p');
+  alertBoxText1.textContent = chrome.i18n.getMessage(
+    'rateLaterHistoryStatusBox429AlertP1'
+  );
+  const alertBoxText2 = document.createElement('p');
+  alertBoxText2.textContent = chrome.i18n.getMessage(
+    'rateLaterHistoryStatusBox429AlertP2'
+  );
+  alertBox.append(alertBoxText1);
+  alertBox.append(alertBoxText2);
+  statusBox.append(alertBox);
+
+  const loader = document.createElement('div');
+  loader.classList.add('lds-dual-ring');
+  statusBox.append(loader);
+
+  const showTooManyRequests = () => {
+    loader.classList.add('display-none');
+    loader.classList.remove('lds-dual-ring');
+    alertBox.classList.remove('display-none');
+    message.classList.add('visibility-hidden');
+
+    stopButton.textContent = chrome.i18n.getMessage(
+      'rateLaterHistoryCloseButtonLabel'
+    );
+  };
+
+  const addCounter = ({ label, initialValue = 0 }) => {
+    const container = document.createElement('div');
+    container.classList.add('counter-section');
+
+    const labelElement = document.createElement('span');
+    labelElement.textContent = label;
+    container.append(labelElement);
+
+    container.append(document.createTextNode(' '));
+
+    const countElement = document.createElement('span');
+    countElement.classList.add('count');
+    container.append(countElement);
+
+    const displayCount = (count) => {
+      countElement.textContent = count.toString();
+    };
+
+    displayCount(initialValue);
+
+    statusBox.append(container);
+
+    return { displayCount };
+  };
+
+  const addCounterList = ({ labels, initialValue = 0 }) => {
+    const container = document.createElement('div');
+    const uList = document.createElement('ul');
+
+    const counters = [];
+
+    labels.forEach((label) => {
+      const lineElement = document.createElement('li');
+      const labelElement = document.createElement('span');
+      labelElement.textContent = label;
+      lineElement.append(labelElement);
+
+      lineElement.append(document.createTextNode(' '));
+
+      const countElement = document.createElement('span');
+      countElement.classList.add('count');
+      lineElement.append(countElement);
+      counters.push(countElement);
+      uList.append(lineElement);
+    });
+
+    container.append(uList);
+
+    const displayCounts = (counts) => {
+      for (let i = 0; i < counts.length; i++) {
+        counters[i].textContent = counts[i].toString();
+      }
+    };
+
+    displayCounts(new Array(labels.length).fill(initialValue));
+    statusBox.append(container);
+
+    return { displayCounts };
+  };
+
+  const { displayCount: displayHistoryVideoCount } = addCounter({
+    label: chrome.i18n.getMessage('rateLaterHistoryVideoCount'),
+  });
+
+  const { displayCount: displayProcessedVideoCount } = addCounter({
+    label: chrome.i18n.getMessage('rateLaterHistoryProcessedCount'),
+  });
+
+  const { displayCounts: displayDetailedVideoCounts } = addCounterList({
+    labels: [
+      chrome.i18n.getMessage('rateLaterHistorySentCount'),
+      chrome.i18n.getMessage('rateLaterHistorySkippedCount'),
+      chrome.i18n.getMessage('rateLaterHistoryFailureCount'),
+    ],
+  });
+
+  const message = document.createElement('p');
+  message.id = 'when-to-stop';
+  message.textContent = chrome.i18n.getMessage(
+    'rateLaterHistoryStatusBoxMessage'
+  );
+  statusBox.append(message);
+
+  const stopButton = document.createElement('button');
+  stopButton.id = 'tournesol-rate-later-history-stop-button';
+  stopButton.classList.add('tournesol-rate-later-history-button');
+  stopButton.textContent = chrome.i18n.getMessage(
+    'rateLaterHistoryStopButtonLabel'
+  );
+  statusBox.append(stopButton);
+
+  const removeOverlay = () => {
+    overlay.remove();
+    document.body.classList.remove('tournesol-capturing-history');
+  };
+
+  return {
+    removeOverlay,
+    displayHistoryVideoCount,
+    displayProcessedVideoCount,
+    displayDetailedVideoCounts,
+    showTooManyRequests,
+    stopButton,
+  };
+};
+
+const addRateLaterBulk = async (videoIds) =>
+  new Promise((resolve, reject) => {
+    chrome.runtime.sendMessage(
+      {
+        message: 'addRateLaterBulk',
+        videoIds,
+      },
+      (response) => {
+        if (response.success) {
+          resolve(response.body);
+        } else {
+          reject(response);
+        }
+      }
+    );
+  });
+
+const skipPreviouslyImported = async (videoSet) => {
+  const newVideos = new Set();
+  const localStorage = await chrome.storage.local.get('youtubeHistoryImported');
+  const historyInStorage = localStorage?.youtubeHistoryImported;
+
+  for (const video of videoSet) {
+    if (!historyInStorage?.includes(video)) {
+      newVideos.add(video);
+    }
+  }
+
+  return newVideos;
+};
+
+const saveImportedToLocalStorage = async (importedVideosSet) => {
+  const localStorage = await chrome.storage.local.get('youtubeHistoryImported');
+  const historyInStorage = localStorage?.youtubeHistoryImported;
+
+  let videosStr = '';
+  for (const video of importedVideosSet) {
+    if (!historyInStorage?.includes(video)) {
+      videosStr += `,${video}`;
+    }
+  }
+
+  if (!historyInStorage) {
+    videosStr = videosStr.substring(1);
+  }
+
+  await chrome.storage.local.set({
+    youtubeHistoryImported: historyInStorage
+      ? historyInStorage + videosStr
+      : videosStr,
+  });
+};
+
+const chunkArray = (array, chunkSize) => {
+  if (chunkSize <= 0) {
+    throw new Error('Chunk size must be greater than 0');
+  }
+
+  const chunks = [];
+
+  for (let i = 0; i < array.length; i += chunkSize) {
+    chunks.push(array.slice(i, i + chunkSize));
+  }
+
+  return chunks;
+};
+
+const addVideoIdsToRateLater = async (videoIds) => {
+  const processedSet = new Set();
+  const failedSet = new Set();
+
+  let addedNbr = 0;
+  let alreadyExistingNbr = 0;
+  let tooManyRequests = false;
+
+  const chunkedVideoIds = chunkArray(
+    Array.from(videoIds),
+    RATE_LATER_BULK_MAX_SIZE
+  );
+
+  for (const chunk of chunkedVideoIds) {
+    try {
+      const videosAddedByChunk = await addRateLaterBulk(chunk);
+      addedNbr += videosAddedByChunk.length;
+      alreadyExistingNbr += chunk.length - videosAddedByChunk.length;
+      chunk.forEach((videoId) => processedSet.add(videoId));
+    } catch (e) {
+      console.error(e);
+      chunk.forEach((videoId) => failedSet.add(videoId));
+      if (e?.status === 429) {
+        tooManyRequests = true;
+        break;
+      }
+    }
+  }
+
+  return {
+    processedSet,
+    failedSet,
+    addedNbr,
+    alreadyExistingNbr,
+    tooManyRequests,
+  };
+};
+
+const forEachVisibleVideoId = (callback) => {
+  const previews = document.querySelectorAll('ytd-video-renderer');
+  previews.forEach((preview) => {
+    const title = preview.querySelector('#video-title');
+    const href = title.getAttribute('href');
+    const params = new URLSearchParams(href.replace(/.*\?/, ''));
+    const videoId = params.get('v');
+    if (videoId) callback(videoId);
+  });
+};
+
+const loadMoreVideos = () => {
+  // Scroll to the bottom of the page to trigger the infinite loader
+  const previews = document.querySelectorAll('ytd-video-renderer');
+  previews[previews.length - 1].scrollIntoView(true);
+};
+
+const startHistoryCapture = async () =>
+  new Promise((resolve) => {
+    // Videos currently visible in the YT history.
+    const historyVideoIdSet = new Set();
+    // Visible videos that have been sent to the Tournesol API.
+    let sentVideoIdSet = new Set();
+    // Visible videos that have been skipped, and not sent to the Tournesol API.
+    let skippedVideoIdSet = new Set();
+
+    let addedCount = 0;
+    let failedCount = 0;
+    let skippedCount = 0;
+    let abort = false;
+
+    const {
+      removeOverlay,
+      displayHistoryVideoCount,
+      displayProcessedVideoCount,
+      displayDetailedVideoCounts,
+      showTooManyRequests,
+      stopButton,
+    } = addOverlay();
+
+    let timeout;
+
+    const abortCapture = ({ close = false } = {}) => {
+      abort = true;
+      if (timeout) clearTimeout(timeout);
+      if (close) {
+        removeOverlay();
+        resolve();
+      }
+    };
+
+    const captureStep = async () => {
+      forEachVisibleVideoId((videoId) => {
+        historyVideoIdSet.add(videoId);
+      });
+
+      displayHistoryVideoCount(historyVideoIdSet.size);
+
+      const videosToSend = historyVideoIdSet
+        .difference(sentVideoIdSet)
+        .difference(skippedVideoIdSet);
+
+      let newVideosToSend = new Set();
+
+      try {
+        newVideosToSend = await skipPreviouslyImported(videosToSend);
+      } catch (error) {
+        console.error(error);
+        newVideosToSend = videosToSend;
+      }
+
+      if (newVideosToSend.size > 0) {
+        const { processedSet, failedSet, tooManyRequests } =
+          await addVideoIdsToRateLater(newVideosToSend);
+
+        try {
+          await saveImportedToLocalStorage(processedSet);
+        } catch (error) {
+          console.error(error);
+        }
+
+        addedCount += processedSet.size;
+        failedCount += failedSet.size;
+
+        sentVideoIdSet = sentVideoIdSet.union(newVideosToSend);
+
+        if (tooManyRequests) {
+          abortCapture();
+          showTooManyRequests();
+          return;
+        }
+      }
+
+      const skipped = videosToSend.difference(newVideosToSend);
+      if (skipped.size > 0) {
+        skippedCount += skipped.size;
+        skippedVideoIdSet = skippedVideoIdSet.union(skipped);
+      }
+
+      displayProcessedVideoCount(addedCount + skippedCount + failedCount);
+      displayDetailedVideoCounts([addedCount, skippedCount, failedCount]);
+
+      if (abort) return;
+
+      loadMoreVideos();
+
+      if (abort) return;
+
+      timeout = setTimeout(captureStep, 1000);
+    };
+    captureStep();
+
+    stopButton.addEventListener('click', () => {
+      abortCapture({ close: true });
+    });
+  });
+
+const isLoggedIn = async () =>
+  new Promise((resolve) => {
+    chrome.runtime.sendMessage({ message: 'isLoggedIn' }, (response) =>
+      resolve(response)
+    );
+  });
+
+const requestLogin = () => {
+  chrome.runtime.sendMessage({ message: 'displayModal' });
+};
+
+const addRateLaterHistoryButton = () => {
+  const buttonId = 'tournesol-rate-later-history-import-button';
+  const previousButton = document.getElementById(buttonId);
+  if (previousButton) previousButton.remove();
+
+  const button = document.createElement('button');
+  button.id = buttonId;
+  button.classList.add('tournesol-rate-later-history-button');
+
+  button.append(chrome.i18n.getMessage('rateLaterHistoryImportButton'));
+
+  button.addEventListener('click', async () => {
+    if (await isLoggedIn()) {
+      try {
+        button.disabled = true;
+        await startHistoryCapture();
+      } finally {
+        button.disabled = false;
+      }
+    } else requestLogin();
+  });
+
+  const menuContents = document.querySelector(
+    'ytd-browse-feed-actions-renderer #contents'
+  );
+  if (menuContents) {
+    // The menu may not be found yet when the History page is the entry page.
+    menuContents.prepend(button);
+  }
+};
+
+onYoutubeReady(() => {
+  addRateLaterHistoryButton();
+});
diff --git a/browser-extension/src/utils.js b/browser-extension/src/utils.js
index 37bd262bec..8bdc2bdb71 100644
--- a/browser-extension/src/utils.js
+++ b/browser-extension/src/utils.js
@@ -89,6 +89,22 @@ export const addRateLater = async (video_id) => {
   };
 };
 
+export const addRateLaterBulk = async (videoIds) => {
+  const rateLaterBulkResponse = await fetchTournesolApi(
+    'users/me/rate_later/videos/_bulk_create',
+    {
+      method: 'POST',
+      data: videoIds.map((videoId) => ({ entity: { uid: 'yt:' + videoId } })),
+    }
+  );
+  const responseJson = await rateLaterBulkResponse.json();
+  return {
+    success: rateLaterBulkResponse.ok,
+    status: rateLaterBulkResponse.status,
+    body: responseJson,
+  };
+};
+
 /**
  * Retrieve the user proof related to the given keyword from the API.
  */
diff --git a/frontend/scripts/openapi.yaml b/frontend/scripts/openapi.yaml
index e856097950..1dcd1d6bb3 100644
--- a/frontend/scripts/openapi.yaml
+++ b/frontend/scripts/openapi.yaml
@@ -2104,6 +2104,49 @@ paths:
       responses:
         '204':
           description: No response body
+  /users/me/rate_later/{poll_name}/_bulk_create:
+    post:
+      operationId: users_me_rate_later__bulk_create_create
+      description: Add a multiple new entities to the logged user's rate-later list,
+        for a given poll.
+      parameters:
+      - in: path
+        name: poll_name
+        schema:
+          type: string
+        required: true
+      tags:
+      - users
+      requestBody:
+        content:
+          application/json:
+            schema:
+              type: array
+              items:
+                $ref: '#/components/schemas/RateLaterRequest'
+          application/x-www-form-urlencoded:
+            schema:
+              type: array
+              items:
+                $ref: '#/components/schemas/RateLaterRequest'
+          multipart/form-data:
+            schema:
+              type: array
+              items:
+                $ref: '#/components/schemas/RateLaterRequest'
+        required: true
+      security:
+      - oauth2:
+        - read write groups
+      responses:
+        '201':
+          content:
+            application/json:
+              schema:
+                type: array
+                items:
+                  $ref: '#/components/schemas/RateLater'
+          description: ''
   /users/me/recommendations/{poll_name}:
     get:
       operationId: users_me_recommendations_list
@@ -3296,12 +3339,12 @@ components:
         * `candidate_fr_2022` - Candidate (FR 2022)
     EventTypeEnum:
       enum:
-      - talk
       - live
+      - talk
       type: string
       description: |-
-        * `talk` - Tournesol Talk
         * `live` - Tournesol Live
+        * `talk` - Tournesol Talk
     ExtendedCollectiveRating:
       type: object
       properties: