Instagram Comment Activity Deleter: Automate the deletion of all your Instagram comments from the 'Your Activity' section. Perfect for quick digital clean-up.

instagram-comment-activity-deleter.js

/**
 * This script automates the process of deleting your own Instagram comments.
 * It deletes comments in batches to avoid hitting rate limits or breaking the page.
 *
 * WARNING: This function directly manipulates the DOM and depends on the current HTML
 *  structure of Instagram's website to work. If Instagram implements changes to the
 *  activity page layout, structure, or functionality, this script may break or cause
 *  unexpected behavior. Use at your own risk and always review code before running it.
 *
 * How to use:
 * 1. Navigate to the Instagram comments page by going to:
 *    https://www.instagram.com/your_activity/interactions/comments
 * 2. Open the developer console in your web browser:
 *    - Chrome/Firefox: Press Ctrl+Shift+J (Windows/Linux) or Cmd+Option+J (Mac)
 *    - Safari: Enable the Develop menu in Safari's Advanced preferences, then press Cmd+Option+C
 * 3. Copy and paste this entire script into the console and press Enter to run it.
 *
 * How to navigate to the comments page on instagram.com:
 * 1. Log in to Instagram on a desktop browser.
 * 2. Go to your profile by clicking on the profile icon at the bottom right.
 * 3. Click on "Your Activity" in the menu.
 * 4. Select "Interactions" and then "Comments".
 * 5. Follow the usage steps above to run this script.
 */
;(async function () {
  // Constants
  /** @const {number} - The number of comments to delete in each batch. */
  const DELETION_BATCH_SIZE = 3
  /** @const {number} - The delay between actions in milliseconds. */
  const DELAY_BETWEEN_ACTIONS_MS = 1000
  /** @const {number} - The delay between clicking the checkboxes in milliseconds. */
  const DELAY_BETWEEN_CHECKBOX_CLICKS_MS = 300
  /** @const {number} - The maximum number of retries for waiting operations */
  const MAX_RETRIES = 60

  /**
   * Utility function that delays execution for a given amount of time.
   * @param {number} ms - The milliseconds to delay.
   * @returns {Promise<void>} A promise that resolves after the specified delay.
   */
  const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms))

  /**
   * Utility function that waits for an element to appear in the DOM before resolving.
   * @param {string} selector - The CSS selector of the element to wait for.
   * @param {number} [timeout=30000] - The maximum time to wait in milliseconds.
   * @returns {Promise<Element>} A promise that resolves with the found element.
   * @throws {Error} If the element is not found within the timeout period.
   */
  const waitForElement = async (selector, timeout = 30000) => {
    const startTime = Date.now()
    while (Date.now() - startTime < timeout) {
      const element = document.querySelector(selector)
      if (element) return element
      await delay(100)
    }
    throw new Error(`Element with selector "${selector}" not found within ${timeout}ms`)
  }

  /**
   * Utility function that clicks on a given element.
   * @param {Element} element - The element to click.
   * @throws {Error} If the element is not found.
   */
  const clickElement = async (element) => {
    if (!element) throw new Error('Element not found')
    element.click()
  }

  /**
   * Waits for the "Select" button to reappear after the page loads more comments
   * following the deletion of a batch of comments when the "Select" button
   * is hidden while a spinner indicates that more comments are loading.
   * @returns {Promise<void>} A promise that resolves when the select button reappears.
   * @throws {Error} If the select button is not found after maximum retries.
   */
  const waitForSelectButton = async () => {
    for (let i = 0; i < MAX_RETRIES; i++) {
      const buttonCount = document.querySelectorAll('[role="button"]')?.length
      if (buttonCount > 1) return
      await delay(1000)
    }
    throw new Error('Select button not found after maximum retries')
  }

  /**
   * Deletes the currently selected comments.
   * @returns {Promise<void>} A promise that resolves when the comments are deleted.
   */
  const deleteSelectedComments = async () => {
    try {
      const deleteButton = await waitForElement('[aria-label="Delete"]')
      await clickElement(deleteButton)
      await delay(DELAY_BETWEEN_ACTIONS_MS)
      const confirmButton = await waitForElement('button[tabindex="0"]')
      await clickElement(confirmButton)
    } catch (error) {
      console.error('Error during comment deletion:', error.message)
    }
  }

  /**
   * Deletes all user comments by selecting comments in batches.
   * @returns {Promise<void>} A promise that resolves when all comments are deleted.
   */
  const deleteActivity = async () => {
    try {
      while (true) {
        const [, selectButton] = document.querySelectorAll('[role="button"]')
        if (!selectButton) throw new Error('Select button not found')

        await clickElement(selectButton)
        await delay(DELAY_BETWEEN_ACTIONS_MS)

        const checkboxes = document.querySelectorAll('[aria-label="Toggle checkbox"]')
        if (checkboxes.length === 0) {
          console.log('No more comments to delete')
          break
        }

        for (let i = 0; i < Math.min(DELETION_BATCH_SIZE, checkboxes.length); i++) {
          await clickElement(checkboxes[i])
          await delay(DELAY_BETWEEN_CHECKBOX_CLICKS_MS)
        }

        await delay(DELAY_BETWEEN_ACTIONS_MS)
        await deleteSelectedComments()
        await delay(DELAY_BETWEEN_ACTIONS_MS)
        await waitForSelectButton()
        await delay(DELAY_BETWEEN_ACTIONS_MS)
      }
    } catch (error) {
      console.error('Error in deleteActivity:', error.message)
    }
  }

  // Start the deletion process
  try {
    await deleteActivity()
    console.log('Activity deletion completed')
  } catch (error) {
    console.error('Fatal error:', error.message)
  }
})()

how to delete likes??

Literally @rathmerdominik's code adapted to Likes.

Use at your own risk. This script manipulates the DOM directly. If Instagram changes their UI, this might stop working.

Instructions:

1. Go to https://www.instagram.com/your_activity/interactions/likes
2. Important: Ensure Instagram language is set to English (US).
3. Open Console (F12 or Cmd+Option+J).
4. Paste the script below and hit Enter.

/**
 * Automated Instagram Unlike Script
 * Adapted from @rathmerdominik's comment cleaner.
 */
; (async function () {
    // Constants
    const DELETION_BATCH_SIZE = 20
    const DELAY_BETWEEN_ACTIONS_MS = 1000
    const DELAY_BETWEEN_CHECKBOX_CLICKS_MS = 150
    const MAX_RETRIES = 60

    // XPath Selectors
    const XPATH_SELECT_BUTTON = "//span[text()='Select']/.."
    const XPATH_UNLIKE_BUTTON = '//span[text()="Unlike"]/../../..'
    const XPATH_CONFIRM_UNLIKE_BUTTON = '//button[div[text()="Unlike"]]'
    const XPATH_ERROR_MODAL_OK_BUTTON = '//button[div[text()="OK"]]'

    // Utilities
    const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms))

    const waitForElementByXpath = async (xpath, timeout = 30000) => {
        const startTime = Date.now()
        while (Date.now() - startTime < timeout) {
            const element = document.evaluate(xpath, document, null, XPathResult.ANY_TYPE, null)?.iterateNext()
            if (element) return element
            await delay(100)
        }
        throw new Error(`Element with selector "${xpath}" not found within ${timeout}ms`)
    }

    const clickElement = async (element) => {
        if (!element) throw new Error('Element not found')
        element.click()
    }

    const waitForSelectButton = async () => {
        for (let i = 0; i < MAX_RETRIES; i++) {
            console.log("Looking for Select Button...")
            const foundSelect = document.evaluate(XPATH_SELECT_BUTTON, document, null, XPathResult.ANY_TYPE, null)?.iterateNext();
            if (foundSelect) return
            await delay(1000)
        }
        throw new Error('Select button not found after maximum retries')
    }

    // --- Core Logic for Likes ---

    const deleteSelectedLikes = async () => {
        try {
            // 1. Click the floating "Unlike" text at the bottom
            const unlikeButton = await waitForElementByXpath(XPATH_UNLIKE_BUTTON)
            await clickElement(unlikeButton)
            await delay(DELAY_BETWEEN_ACTIONS_MS)
            
            // 2. Click the confirm "Unlike" in the popup modal
            const confirmButton = await waitForElementByXpath(XPATH_CONFIRM_UNLIKE_BUTTON)
            await clickElement(confirmButton)
        } catch (error) {
            console.error('Error during like deletion:', error.message)
        }
    }

    const unlikeActivity = async () => {
        try {
            while (true) {
                // Find "Select" button
                const allSpans = Array.from(document.querySelectorAll('span'));
                const selectButton = allSpans.find(span => span.textContent === 'Select')?.parentElement;
                
                if (!selectButton) {
                     // Check if empty state or just loading
                     const noResults = Array.from(document.querySelectorAll('span')).some(s => s.textContent === 'No content found');
                     if(noResults) {
                         console.log("No more likes found. Done!");
                         break;
                     }
                     console.log("Waiting for Select button...");
                     await delay(2000);
                     continue;
                }

                await clickElement(selectButton)
                await delay(DELAY_BETWEEN_ACTIONS_MS)

                // Find checkboxes
                const checkboxes = document.querySelectorAll('[aria-label="Toggle checkbox"]')
                
                // Handle limits or empty states
                if (checkboxes.length === 0) {
                    const isInstagramFunny = document.evaluate(XPATH_ERROR_MODAL_OK_BUTTON, document, null, XPathResult.ANY_TYPE, null)?.iterateNext();
                    if (isInstagramFunny) {
                        console.log('Instagram rate limit hit, clicking OK...')
                        await clickElement(isInstagramFunny)
                        await delay(DELAY_BETWEEN_ACTIONS_MS * 5) // Wait longer if error
                        waitForSelectButton()
                        continue
                    } else {
                        console.log('No checkboxes found. Finishing...')
                        break
                    }
                }

                // Select items
                console.log(`Selecting ${Math.min(DELETION_BATCH_SIZE, checkboxes.length)} items...`)
                for (let i = 0; i < Math.min(DELETION_BATCH_SIZE, checkboxes.length); i++) {
                    await clickElement(checkboxes[i])
                    await delay(DELAY_BETWEEN_CHECKBOX_CLICKS_MS)
                }

                // Delete items
                await delay(DELAY_BETWEEN_ACTIONS_MS)
                await deleteSelectedLikes()
                
                // Wait for reload
                await delay(DELAY_BETWEEN_ACTIONS_MS)
                await waitForSelectButton()
                await delay(DELAY_BETWEEN_ACTIONS_MS)
            }
        } catch (error) {
            console.error('Error in unlikeActivity:', error.message)
        }
    }

    // Start execution
    try {
        console.log("Starting script to UNLIKE posts...")
        await unlikeActivity()
        console.log('Likes deletion completed')
    } catch (error) {
        console.error('Fatal error:', error.message)
    }
})()

i ran the script and it said " No more comments to delete
Activity deletion completed " instantly after i pressed enter when i see no comment being deleted at all, i dont know anything about codes n stuff, im just here to delete my comments. Can anyone help me

it checks the boxes until the value but it doesnt delete automatically

Added an author whitelist feature, add post authors you want to keep your comments under to AUTHOR_WHITELIST constant :)

/**
 * This script automates the process of deleting your own Instagram comments.
 * It deletes comments in batches to avoid hitting rate limits or breaking the page.
 *
 * WARNING: This function directly manipulates the DOM and depends on the current HTML
 *  structure of Instagram's website to work. If Instagram implements changes to the
 *  activity page layout, structure, or functionality, this script may break or cause
 *  unexpected behavior. Use at your own risk and always review code before running it.
 *
 * How to use:
 * 1. Navigate to the Instagram comments page by going to:
 *    https://www.instagram.com/your_activity/interactions/comments
 * 2. Open the developer console in your web browser:
 *    - Chrome/Firefox: Press Ctrl+Shift+J (Windows/Linux) or Cmd+Option+J (Mac)
 *    - Safari: Enable the Develop menu in Safari's Advanced preferences, then press Cmd+Option+C
 * 3. Copy and paste this entire script into the console and press Enter to run it.
 *
 * How to navigate to the comments page on instagram.com:
 * 1. Log in to Instagram on a desktop browser.
 * 2. Go to your profile by clicking on the profile icon at the bottom right.
 * 3. Click on "Your Activity" in the menu.
 * 4. Select "Interactions" and then "Comments".
 * 5. Follow the usage steps above to run this script.
 */
; (async function () {
    // Constants
    /** @const {number} - The number of comments to delete in each batch. */
    const DELETION_BATCH_SIZE = 20
    /** @const {number} - The delay between actions in milliseconds. */
    const DELAY_BETWEEN_ACTIONS_MS = 700
    /** @const {number} - The delay between clicking the checkboxes in milliseconds. */
    const DELAY_BETWEEN_CHECKBOX_CLICKS_MS = 100
    /** @const {number} - The maximum number of retries for waiting operations */
    const MAX_RETRIES = 60
    /** @const {string[]} - Accounts you don't want to delete comments under. */
    const AUTHOR_WHITELIST = []

    /** @const {string} - The XPath selector for the "Select" button */
    const XPATH_SELECT_BUTTON = "//span[text()='Select']/.."
    /** @const {string} - The XPath selector for the "Delete" button */
    const XPATH_DELETE_BUTTON = '//span[text()="Delete"]/../../..'
    /** @const {string} - The XPath selector for the "Delete" button in the confirm dialog */
    const XPATH_CONFIRM_DELETE_BUTTON = '//button[div[text()="Delete"]]'
    /** @const {string} - The OK button of the Error modal that comes up when Instagram feels like being funny */
    const XPATH_ERROR_MODAL_OK_BUTTON = '//button[div[text()="OK"]]'

    /**
     * Utility function that delays execution for a given amount of time.
     * @param {number} ms - The milliseconds to delay.
     * @returns {Promise<void>} A promise that resolves after the specified delay.
     */
    const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms))

    /**
     * Utility function that waits for an element to appear in the DOM before resolving.
     * @param {string} selector - The XPath of the element to wait for.
     * @param {number} [timeout=30000] - The maximum time to wait in milliseconds.
     * @returns {Promise<Element>} A promise that resolves with the found element.
     * @throws {Error} If the element is not found within the timeout period.
     */
    const waitForElementByXpath = async (xpath, timeout = 30000) => {
        const startTime = Date.now()
        while (Date.now() - startTime < timeout) {
            const element = document.evaluate(xpath, document, null, XPathResult.ANY_TYPE, null)?.iterateNext()
            if (element) return element
            await delay(100)
        }
        throw new Error(`Element with selector "${selector}" not found within ${timeout}ms`)
    }
    
    /**
     * Utility function that resolves the post author from the checkbox.
     * @param {Element} element - The checkbox to resolve post author from.
     * @returns {string} author - The post author.
     * @throws {Error} If the post author cannot be resolved.
     */
     const resolveAuthor = (element) => {
         const postContainer = element.closest('[style*="pointer-events: none; flex-direction: column;"]');
         if (!postContainer) throw new Error("Could not resolve post container");
         
         const author = postContainer.querySelector("span");
         if (!author) throw new Error("Could not resolve author")
         
         return author.innerText.trim();
     }
    

    /**
     * Utility function that clicks on a given element.
     * @param {Element} element - The element to click.
     * @throws {Error} If the element is not found.
     */
    const clickElement = async (element) => {
        if (!element) throw new Error('Element not found')
        element.click()
    }

    /**
     * Waits for the "Select" button to reappear after the page loads more comments
     * following the deletion of a batch of comments when the "Select" button
     * is hidden while a spinner indicates that more comments are loading.
     * @returns {Promise<void>} A promise that resolves when the select button reappears.
     * @throws {Error} If the select button is not found after maximum retries.
     */
    const waitForSelectButton = async () => {
        for (let i = 0; i < MAX_RETRIES; i++) {
            console.log("Trying to find Select Button")

            const foundSelect = document.evaluate(XPATH_SELECT_BUTTON, document, null, XPathResult.ANY_TYPE, null)?.iterateNext();
            if (foundSelect) return
            await delay(1000)
        }
        throw new Error('Select button not found after maximum retries')
    }

    /**
     * Deletes the currently selected comments.
     * @returns {Promise<void>} A promise that resolves when the comments are deleted.
     */
    const deleteSelectedComments = async () => {
        try {
            const deleteButton = await waitForElementByXpath(XPATH_DELETE_BUTTON)
            await clickElement(deleteButton)
            await delay(DELAY_BETWEEN_ACTIONS_MS)
            const confirmButton = await waitForElementByXpath(XPATH_CONFIRM_DELETE_BUTTON)
            await clickElement(confirmButton)
        } catch (error) {
            console.error('Error during comment deletion:', error.message)
        }
    }

    /**
     * Deletes all user comments by selecting comments in batches.
     * @returns {Promise<void>} A promise that resolves when all comments are deleted.
     */
    const deleteActivity = async () => {
        try {
            while (true) {
                // Find all spans that say "Select"
                const allSpans = Array.from(document.querySelectorAll('span'));
                const selectButton = allSpans.find(span => span.textContent === 'Select')?.parentElement;
                if (!selectButton) throw new Error('Select button not found')

                await clickElement(selectButton)
                await delay(DELAY_BETWEEN_ACTIONS_MS)

                const checkboxes = document.querySelectorAll('[aria-label="Toggle checkbox"]')
                if (checkboxes.length === 0) {
                    const isInstagramFunny = document.evaluate(XPATH_ERROR_MODAL_OK_BUTTON, document, null, XPathResult.ANY_TYPE, null)?.iterateNext();
                    if (isInstagramFunny) {
                        console.log('Instagram rate limit hit, clicking OK on error modal')
                        await clickElement(isInstagramFunny)
                        await delay(DELAY_BETWEEN_ACTIONS_MS)
                        waitForSelectButton()
                        await delay(DELAY_BETWEEN_ACTIONS_MS)
                        continue
                    } else {
                        console.log('No more comments to delete')
                        break
                    }
                }

                for (let i = 0; i < Math.min(DELETION_BATCH_SIZE, checkboxes.length); i++) {
                    if (AUTHOR_WHITELIST.includes(
                        resolveAuthor(checkboxes[i])
                    )) continue;
                    
                    await clickElement(checkboxes[i])
                    await delay(DELAY_BETWEEN_CHECKBOX_CLICKS_MS)
                }

                await delay(DELAY_BETWEEN_ACTIONS_MS)
                await deleteSelectedComments()
                await delay(DELAY_BETWEEN_ACTIONS_MS)
                await waitForSelectButton()
                await delay(DELAY_BETWEEN_ACTIONS_MS)
            }
        } catch (error) {
            console.error('Error in deleteActivity:', error.message)
        }
    }

    // Start the deletion process
    try {
        await deleteActivity()
        console.log('Activity deletion completed')
    } catch (error) {
        console.error('Fatal error:', error.message)
    }
})()

I MADE ACCOUNT JUST TO SAY GOD BLESS YOU @kystreich

Added an author whitelist feature, add post authors you want to keep your comments under to AUTHOR_WHITELIST constant :)

/**
 * This script automates the process of deleting your own Instagram comments.
 * It deletes comments in batches to avoid hitting rate limits or breaking the page.
 *
 * WARNING: This function directly manipulates the DOM and depends on the current HTML
 *  structure of Instagram's website to work. If Instagram implements changes to the
 *  activity page layout, structure, or functionality, this script may break or cause
 *  unexpected behavior. Use at your own risk and always review code before running it.
 *
 * How to use:
 * 1. Navigate to the Instagram comments page by going to:
 *    https://www.instagram.com/your_activity/interactions/comments
 * 2. Open the developer console in your web browser:
 *    - Chrome/Firefox: Press Ctrl+Shift+J (Windows/Linux) or Cmd+Option+J (Mac)
 *    - Safari: Enable the Develop menu in Safari's Advanced preferences, then press Cmd+Option+C
 * 3. Copy and paste this entire script into the console and press Enter to run it.
 *
 * How to navigate to the comments page on instagram.com:
 * 1. Log in to Instagram on a desktop browser.
 * 2. Go to your profile by clicking on the profile icon at the bottom right.
 * 3. Click on "Your Activity" in the menu.
 * 4. Select "Interactions" and then "Comments".
 * 5. Follow the usage steps above to run this script.
 */
; (async function () {
    // Constants
    /** @const {number} - The number of comments to delete in each batch. */
    const DELETION_BATCH_SIZE = 20
    /** @const {number} - The delay between actions in milliseconds. */
    const DELAY_BETWEEN_ACTIONS_MS = 700
    /** @const {number} - The delay between clicking the checkboxes in milliseconds. */
    const DELAY_BETWEEN_CHECKBOX_CLICKS_MS = 100
    /** @const {number} - The maximum number of retries for waiting operations */
    const MAX_RETRIES = 60
    /** @const {string[]} - Accounts you don't want to delete comments under. */
    const AUTHOR_WHITELIST = []

    /** @const {string} - The XPath selector for the "Select" button */
    const XPATH_SELECT_BUTTON = "//span[text()='Select']/.."
    /** @const {string} - The XPath selector for the "Delete" button */
    const XPATH_DELETE_BUTTON = '//span[text()="Delete"]/../../..'
    /** @const {string} - The XPath selector for the "Delete" button in the confirm dialog */
    const XPATH_CONFIRM_DELETE_BUTTON = '//button[div[text()="Delete"]]'
    /** @const {string} - The OK button of the Error modal that comes up when Instagram feels like being funny */
    const XPATH_ERROR_MODAL_OK_BUTTON = '//button[div[text()="OK"]]'

    /**
     * Utility function that delays execution for a given amount of time.
     * @param {number} ms - The milliseconds to delay.
     * @returns {Promise<void>} A promise that resolves after the specified delay.
     */
    const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms))

    /**
     * Utility function that waits for an element to appear in the DOM before resolving.
     * @param {string} selector - The XPath of the element to wait for.
     * @param {number} [timeout=30000] - The maximum time to wait in milliseconds.
     * @returns {Promise<Element>} A promise that resolves with the found element.
     * @throws {Error} If the element is not found within the timeout period.
     */
    const waitForElementByXpath = async (xpath, timeout = 30000) => {
        const startTime = Date.now()
        while (Date.now() - startTime < timeout) {
            const element = document.evaluate(xpath, document, null, XPathResult.ANY_TYPE, null)?.iterateNext()
            if (element) return element
            await delay(100)
        }
        throw new Error(`Element with selector "${selector}" not found within ${timeout}ms`)
    }
    
    /**
     * Utility function that resolves the post author from the checkbox.
     * @param {Element} element - The checkbox to resolve post author from.
     * @returns {string} author - The post author.
     * @throws {Error} If the post author cannot be resolved.
     */
     const resolveAuthor = (element) => {
         const postContainer = element.closest('[style*="pointer-events: none; flex-direction: column;"]');
         if (!postContainer) throw new Error("Could not resolve post container");
         
         const author = postContainer.querySelector("span");
         if (!author) throw new Error("Could not resolve author")
         
         return author.innerText.trim();
     }
    

    /**
     * Utility function that clicks on a given element.
     * @param {Element} element - The element to click.
     * @throws {Error} If the element is not found.
     */
    const clickElement = async (element) => {
        if (!element) throw new Error('Element not found')
        element.click()
    }

    /**
     * Waits for the "Select" button to reappear after the page loads more comments
     * following the deletion of a batch of comments when the "Select" button
     * is hidden while a spinner indicates that more comments are loading.
     * @returns {Promise<void>} A promise that resolves when the select button reappears.
     * @throws {Error} If the select button is not found after maximum retries.
     */
    const waitForSelectButton = async () => {
        for (let i = 0; i < MAX_RETRIES; i++) {
            console.log("Trying to find Select Button")

            const foundSelect = document.evaluate(XPATH_SELECT_BUTTON, document, null, XPathResult.ANY_TYPE, null)?.iterateNext();
            if (foundSelect) return
            await delay(1000)
        }
        throw new Error('Select button not found after maximum retries')
    }

    /**
     * Deletes the currently selected comments.
     * @returns {Promise<void>} A promise that resolves when the comments are deleted.
     */
    const deleteSelectedComments = async () => {
        try {
            const deleteButton = await waitForElementByXpath(XPATH_DELETE_BUTTON)
            await clickElement(deleteButton)
            await delay(DELAY_BETWEEN_ACTIONS_MS)
            const confirmButton = await waitForElementByXpath(XPATH_CONFIRM_DELETE_BUTTON)
            await clickElement(confirmButton)
        } catch (error) {
            console.error('Error during comment deletion:', error.message)
        }
    }

    /**
     * Deletes all user comments by selecting comments in batches.
     * @returns {Promise<void>} A promise that resolves when all comments are deleted.
     */
    const deleteActivity = async () => {
        try {
            while (true) {
                // Find all spans that say "Select"
                const allSpans = Array.from(document.querySelectorAll('span'));
                const selectButton = allSpans.find(span => span.textContent === 'Select')?.parentElement;
                if (!selectButton) throw new Error('Select button not found')

                await clickElement(selectButton)
                await delay(DELAY_BETWEEN_ACTIONS_MS)

                const checkboxes = document.querySelectorAll('[aria-label="Toggle checkbox"]')
                if (checkboxes.length === 0) {
                    const isInstagramFunny = document.evaluate(XPATH_ERROR_MODAL_OK_BUTTON, document, null, XPathResult.ANY_TYPE, null)?.iterateNext();
                    if (isInstagramFunny) {
                        console.log('Instagram rate limit hit, clicking OK on error modal')
                        await clickElement(isInstagramFunny)
                        await delay(DELAY_BETWEEN_ACTIONS_MS)
                        waitForSelectButton()
                        await delay(DELAY_BETWEEN_ACTIONS_MS)
                        continue
                    } else {
                        console.log('No more comments to delete')
                        break
                    }
                }

                for (let i = 0; i < Math.min(DELETION_BATCH_SIZE, checkboxes.length); i++) {
                    if (AUTHOR_WHITELIST.includes(
                        resolveAuthor(checkboxes[i])
                    )) continue;
                    
                    await clickElement(checkboxes[i])
                    await delay(DELAY_BETWEEN_CHECKBOX_CLICKS_MS)
                }

                await delay(DELAY_BETWEEN_ACTIONS_MS)
                await deleteSelectedComments()
                await delay(DELAY_BETWEEN_ACTIONS_MS)
                await waitForSelectButton()
                await delay(DELAY_BETWEEN_ACTIONS_MS)
            }
        } catch (error) {
            console.error('Error in deleteActivity:', error.message)
        }
    }

    // Start the deletion process
    try {
        await deleteActivity()
        console.log('Activity deletion completed')
    } catch (error) {
        console.error('Fatal error:', error.message)
    }
})()

This is awseome, however it doesnt function as expected if you have a large number of comments on the users you wish to whitelist. Eventualy it gets stuck at "trying to find select button, 0 selected". I'm not super familiar with JS but I'll probably try to solve that eventually