A script you can run in browser dev tools that will automatically unpin all pinned notes in google keep.

unpinAllGoogleKeepNotes.js

/*

WARNING: This has the side effect of reversing the note order, since it unpins the most recent notes to oldest, the notes end up getting added to the 
unpinned list in the order they got unpinned.  TLDR: The last pinned notes show up at the top of the unpinned list, since they 
are the most recenlty unpinned ones.


To work with the script in the browser's Developer Tools just like you would with a normal JavaScript file and set breakpoints, you can follow these steps:

1. **Open the Sources Tab in DevTools**  
The Sources tab in Chrome DevTools is where you can view, debug, and set breakpoints in JavaScript running on the webpage.

- Open your website (e.g., Google Keep).
- Press `F12` (or `Ctrl + Shift + I`) to open Developer Tools.
- Switch to the **Sources** tab.

2. **Inject the Script into the Page (for Debugging)**  
In the Sources tab, you can add a new file or edit an existing one. Here's how to do it for the script we’ve been discussing:

**Option 1: Create a New Snippet in DevTools**  
- **Create a Snippet**:
  - In the Sources tab, on the left side, you’ll see a panel called **File Navigator**.
  - Right-click inside this panel and select **New Snippet**.
  - Name the snippet, for example, `unpinNotes.js`.

- **Paste Your Script**:
  - Paste your JavaScript code into the snippet editor.

- **Set Breakpoints**:
  - You can now click in the gutter next to any line number in the code to set breakpoints. A breakpoint will pause the execution of the script at that line, allowing you to inspect variables, step through the code, and debug.

- **Run the Snippet**:
  - Once you’ve added breakpoints, you can run the snippet by right-clicking on the snippet and selecting **Run**.
  - Your script will execute, and it will stop at any breakpoints you set.
*/
(function unpinAllNotes() {
  console.log("Starting the unpinning process...");

  // Function to simulate mouse events
  function simulateMouseEvent(element, eventType) {
    const mouseEvent = new MouseEvent(eventType, {
      bubbles: true,
      cancelable: true,
      view: window,
      button: 0, // Left mouse button
      buttons: 1, // Left mouse button is pressed
    });

    element.dispatchEvent(mouseEvent);
  }

  // Function to simulate key events
  function simulateKeyEvent(element, keyCode) {
    const event = new KeyboardEvent('keydown', {
      keyCode: keyCode, // 32 is the keyCode for spacebar
      bubbles: true,
      cancelable: true,
      view: window
    });

    element.dispatchEvent(event);
  }

  // Function to check if a note has been unpinned (based on its containing element removal)
  function waitForNoteRemoval(noteElement, callback) {
    console.log("Setting up removal observer for note...");

    const observer = new MutationObserver((mutationsList) => {
      for (const mutation of mutationsList) {
        // If the note element has been removed, call the callback
        if (!document.contains(noteElement)) {
          observer.disconnect();
          console.log("Note removed. Proceeding to unpin the next note.");
          callback();
          return;
        }
      }
    });

    observer.observe(noteElement.parentElement, {
      childList: true,
      subtree: true
    });
  }


  // Function to keep checking if there are pinned notes every 100ms
  function keepCheckingForPinnedNotes() {
    let timeoutReached = false;
    const checkInterval = 100; // Interval to check for new pinned notes
    const maxWaitTime = 15000; // Max wait time in milliseconds (15 seconds)
    const startTime = Date.now();

    function check() {
      const timeElapsed = Date.now() - startTime;
      if (timeElapsed >= maxWaitTime) {
        timeoutReached = true;
        console.log("Max wait time reached. No more pinned notes to unpin.");
        return;
      }

      // Check if there is a pinned note to unpin and try to unpin it
      const pinButton = document.querySelector('div[aria-pressed="true"][data-tooltip-text="Unpin note"]');
      if (pinButton) {
        unpinNote(); // Start unpinning the first found pinned note
      } else if (!timeoutReached) {
        // If no pinned note is found, check again after 100ms
        setTimeout(check, checkInterval);
      }
    }

    // Start the repeated check
    check();
  }
  
  // Function to unpin a single note
  function unpinNote() {
    console.log("Checking for the first pinned note to unpin...");

    // Find the first pinned note at the top (aria-pressed="true" indicates the note is pinned)
    const pinButton = document.querySelector('div[aria-pressed="true"][data-tooltip-text="Unpin note"]');

    if (!pinButton) {
      console.log("No more pinned notes to unpin.");
      
      // Start the unpinning process by checking for pinned notes
      keepCheckingForPinnedNotes();
      return;
    }

    // Find the note element that contains the pinned note by traversing up the DOM
    const noteElement = pinButton.closest('.IZ65Hb-n0tgWb');

    if (!noteElement) {
      console.log('Error: Could not find the note element associated with this pin button.');
      return;
    }

    console.log(`Setting up removal observer for note: ${noteElement}`);
    
    // Attach a handler to wait for the note element to be removed
    waitForNoteRemoval(noteElement, () => {
      console.log("Note unpinned and removed. Processing next...");
      unpinNote(); // Process the next note after this one is removed
    });
  
    console.log("Unpinning note:", noteElement);
    
    // Simulate focusing and then pressing the spacebar
    //pinButton.focus();
    //simulateKeyEvent(pinButton, 32); // 32 is the keyCode for the spacebar
    
    // Simulate a mousedown, mouseup, and click event to unpin the note
    simulateMouseEvent(pinButton, 'mousedown');
    simulateMouseEvent(pinButton, 'mouseup');
    simulateMouseEvent(pinButton, 'click');
  }

  unpinNote(); // Start unpinning the first found pinned note
})();