I came across this problem when I wanted to delete all my Youtube Comments on other videos without removing my entire channel.

As far as I know there is no native way to delete them and they have to be deleted manually 1 by 1. Well, nothing has to be done manually in this time and age of automation, so here I would like to share my auto-remove JavaScript with you.

**Step 1:**
Go to https://myactivity.google.com/page?hl=de&utm_medium=web&utm_source=youtube&page=youtube_comments

**Step 2:**
Press F12 to open the Browser console and navigate to "Console" (in Firefox it is called like this, not sure about other browsers, but they all have this kind of debugging feature)

**Step 3:**
Paste in this script and let it run. Sometimes the process gets stuck or falters, but it should work for quite a long time. You can increase the delays to make sure it keeps up with your internet speed and PC/Browser specs. If it stops working, simply refresh the page and paste the code again.
Upon pasting it a first time, the browser might warn you and ask you to type something into the console to make sure you know what you're doing. If you want to be able to paste the script and execute it, you will have to follow this instructions.


**CAUTION: Use on your own risk as some websites might have policy against automated actions like this!!!**

Script:

    (async function autoDeleteYouTubeComments() {
    // Configuration
    const DELETE_ARIA_LABEL = "Aktivitätselement löschen"; // Part of aria-label for delete buttons
    const DELETE_DELAY_MIN = 300; // Minimum delay time in ms (0.3 seconds)
    const DELETE_DELAY_MAX = 1200; // Maximum delay time in ms (1.2 seconds)
    const COMMENTS_BEFORE_PAUSE = 20; // Number of comments to delete before pausing
    const PAUSE_TIME = 5000; // 5 seconds pause after deleting COMMENTS_BEFORE_PAUSE comments
    const SCROLL_DELAY = 250; // Delay between scroll attempts to load new content (in ms)
    const MAX_SCROLL_ATTEMPTS = 5; // Maximum number of scroll attempts
    const MAX_NEARBY_ATTEMPTS = 10; // Maximum attempts to find a new nearby button

    let clickedButtons = []; // Array to store buttons that have already been clicked

    // Utility function to pause execution for a given time
    function sleep(ms) {
        return new Promise(resolve => setTimeout(resolve, ms));
    }

    // Function to scroll down until all content is loaded, with a limit of 5 attempts
    async function scrollToEnd() {
        let lastHeight = document.body.scrollHeight;
        let attempts = 0;

        console.log("Starting to scroll down to load all content...");

        while (attempts < MAX_SCROLL_ATTEMPTS) {
            window.scrollTo(0, document.body.scrollHeight);
            await sleep(SCROLL_DELAY);

            let newHeight = document.body.scrollHeight;

            if (newHeight === lastHeight) {
                attempts++;
                console.log(`No new content loaded. Attempt ${attempts}/${MAX_SCROLL_ATTEMPTS}.`);
            } else {
                attempts = 0; // Reset the attempts if new content is loaded
                lastHeight = newHeight;
                console.log("New content loaded, continuing to scroll...");
            }
        }

        console.log("Finished scrolling. All content should now be loaded.");
    }

    // Function to scroll back to the top of the page
    async function scrollToTop() {
        console.log("Scrolling back to the top...");
        window.scrollTo(0, 0);
        await sleep(1000); // Wait for the scroll to complete
        console.log("Scrolled to the top.");
    }

    // Function to find the next delete button by checking the aria-label for "Aktivitätselement löschen"
    function findDeleteButtons() {
        const buttons = Array.from(document.querySelectorAll('button'));
        const deleteButtons = buttons.filter(button => {
            const ariaLabel = button.getAttribute('aria-label') || '';
            const innerText = button.innerText || '';
            const classList = button.classList || [];

            // Ensure we do not select the revert button
            const isRevertButton = innerText.includes("Abbrechen") || classList.contains("x95qze");
            
            // Only return delete buttons that match this aria-label and are not revert buttons
            return ariaLabel.startsWith(DELETE_ARIA_LABEL) && !isRevertButton;
        });

        return deleteButtons; // Return all delete buttons found
    }

    // Function to generate a random delay between DELETE_DELAY_MIN and DELETE_DELAY_MAX
    function getRandomDeleteDelay() {
        return Math.random() * (DELETE_DELAY_MAX - DELETE_DELAY_MIN) + DELETE_DELAY_MIN;
    }

    // Function to pick a nearby delete button
    function pickNearbyDeleteButton(deleteButtons, currentIndex) {
        const nearbyRange = 2; // Define the range of nearby buttons (±2 positions)
        const startIndex = Math.max(0, currentIndex - nearbyRange); // Prevent going out of bounds
        const endIndex = Math.min(deleteButtons.length - 1, currentIndex + nearbyRange); // Prevent going out of bounds

        // Randomly select an index from the nearby range
        const nearbyIndex = Math.floor(Math.random() * (endIndex - startIndex + 1)) + startIndex;
        return deleteButtons[nearbyIndex];
    }

    // Function to pick a completely random delete button
    function pickRandomDeleteButton(deleteButtons) {
        const randomIndex = Math.floor(Math.random() * deleteButtons.length);
        return deleteButtons[randomIndex];
    }

    // Main function to handle deletion
    async function deleteComments() {
        let deletedCount = 0; // Initialize a counter to track the number of deleted comments
        let currentIndex = 0; // Keep track of the current delete button index

        while (true) {
            // Refresh the list of delete buttons after each deletion
            const deleteButtons = findDeleteButtons();

            // If no delete button is found, stop the script
            if (deleteButtons.length === 0) {
                console.log("No more delete buttons found. Stopping.");
                break;
            }

            let deleteButton;
            let attempts = 0;
            let isButtonNew = false;

            // Try to find a "new" nearby delete button
            while (attempts < MAX_NEARBY_ATTEMPTS) {
                deleteButton = pickNearbyDeleteButton(deleteButtons, currentIndex);
                if (!clickedButtons.includes(deleteButton)) {
                    isButtonNew = true;
                    break; // Found a new button
                }
                attempts++;
            }

            // If nearby attempts failed, pick a completely random delete button
            if (!isButtonNew) {
                console.log("Couldn't find a nearby new button after 10 attempts. Picking a random button.");
                deleteButton = pickRandomDeleteButton(deleteButtons);
            }

            // Scroll to the delete button to visualize the deletion
            deleteButton.scrollIntoView({ behavior: 'smooth', block: 'center' });
            console.log("Scrolling to the delete button...");

            await sleep(1000); // Wait a moment to let the user see the scroll

            // Click the delete button
            deleteButton.click();
            console.log("Delete button clicked.");

            // Add the clicked button to the clickedButtons array
            clickedButtons.push(deleteButton);

            // Increment the deleted comment counter
            deletedCount++;
            console.log(`Deleted ${deletedCount} comment(s). Remaining delete buttons: ${deleteButtons.length - 1}`);

            // Update the current index (randomly choose a new nearby index)
            currentIndex = deleteButtons.indexOf(deleteButton);

            // Wait for the deletion to process with a random delay before the next action
            const randomDelay = getRandomDeleteDelay();
            console.log(`Waiting for ${randomDelay.toFixed(0)}ms before refreshing and checking for the next deletion.`);
            await sleep(randomDelay);

            // Pause for 5 seconds after every 20 deletions
            if (deletedCount % COMMENTS_BEFORE_PAUSE === 0) {
                console.log(`Pausing for ${PAUSE_TIME / 1000} seconds after deleting ${deletedCount} comments...`);
                await sleep(PAUSE_TIME);
            }
        }

        console.log("All deletions completed.");
    }

    // Execute the steps
    await scrollToEnd(); // Scroll down to load all content
    await scrollToTop(); // Scroll back to the top of the page
    await deleteComments(); // Start deleting comments
})();


I deleted 3,000 comments this way and it only took one hour of keeping my browser open in the background.

This code does not only do what it should, it looks damn cool while doing it (the way it scrolls around to find buttons to delete in the vicinity just feels really snappy!)