Skip to content
TheChatArchiveThe Chat Archive
Geminigemini-2.5-pro· GoogleHugging Face LMArena Human Preference 140K

I would like to access my notes and reminders from Apple in my python scripts. Is there…

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with chatgpt-4o-latest-20250326’s answer.
  1. User

    I would like to access my notes and reminders from Apple in my python scripts. Is there a way to do so?

  2. Gemini Assistant

    Of course! Accessing Apple Notes and Reminders from Python is a common request, but it's important to know that Apple doesn't provide an official, public API for this. Therefore, the methods we use are workarounds, each with its own set of advantages and limitations.

    Here’s a breakdown of the most effective methods, primarily for users on macOS. I'll also cover a cross-platform option.


    Summary of Methods

    MethodApplicationPlatformProsCons
    1. AppleScript (via Python subprocess)RemindersmacOSReliable, "officially" sanctioned way to automate.Only works on macOS. A bit clunky to write/parse.
    2. Direct SQLite Database AccessNotesmacOSFast, direct access to all note content.Fragile! Database schema can change with any OS update.
    3. Third-Party Library (pyicloud)BothAllWorks cross-platform (Windows, Linux, macOS).Security risk (needs password), may break with iCloud changes.

    Method 1: Accessing Reminders with AppleScript (macOS Only)

    This is the most reliable and recommended method for interacting with Reminders on a Mac. You use Python to execute an AppleScript command.

    Reading Reminders

    You can get all reminders from a specific list.

    import subprocess
    import shlex
    
    def get_apple_reminders(list_name):
        """
        Retrieves all reminders from a specific list in Apple Reminders.
        
        Args:
            list_name (str): The name of the Reminders list.
            
        Returns:
            A list of reminder titles (strings).
        """
        # AppleScript to get the names of reminders in a specific list
        script = f'''
        tell application "Reminders"
            set reminder_names to {{}}
            set all_reminders to every reminder in list "{list_name}" whose completed is false
            repeat with a_reminder in all_reminders
                copy name of a_reminder to the end of reminder_names
            end repeat
            return reminder_names
        end tell
        '''
        
        try:
            # The osascript command expects the script as separate arguments
            # We use shlex.split to handle this properly
            cmd = ['osascript', '-e', script]
            
            # Execute the command
            result = subprocess.run(cmd, capture_output=True, text=True, check=True)
            
            # The output is a string like "item 1, item 2, item 3"
            # We clean it up and split it into a list
            output = result.stdout.strip()
            if not output:
                return []
            return [item.strip() for item in output.split(',')]
    
        except subprocess.CalledProcessError as e:
            print(f"Error executing AppleScript: {e}")
            print(f"Stderr: {e.stderr}")
            return None
    
    # --- Example Usage ---
    if __name__ == "__main__":
        my_list = "Groceries"  # <--- CHANGE THIS to your list name
        reminders = get_apple_reminders(my_list)
        
        if reminders is not None:
            print(f"Reminders in list '{my_list}':")
            for i, reminder in enumerate(reminders):
                print(f"{i+1}. {reminder}")
    

    Creating a Reminder

    You can also create new reminders just as easily.

    def create_apple_reminder(list_name, title, body=None):
        """
        Creates a new reminder in a specific list.
        
        Args:
            list_name (str): The name of the list to add the reminder to.
            title (str): The title of the new reminder.
            body (str, optional): The note/body of the reminder. Defaults to None.
        """
        body_script = f'set body of new_reminder to "{body}"' if body else ""
        
        script = f'''
        tell application "Reminders"
            tell list "{list_name}"
                set new_reminder to make new reminder with properties {{name:"{title}"}}
                {body_script}
            end tell
        end tell
        '''
        
        try:
            cmd = ['osascript', '-e', script]
            subprocess.run(cmd, check=True)
            print(f"Successfully created reminder '{title}' in list '{list_name}'.")
        except subprocess.CalledProcessError as e:
            print(f"Error creating reminder: {e}")
    
    # --- Example Usage ---
    if __name__ == "__main__":
        create_apple_reminder("Tasks", "Write Python script for reminders", body="Don't forget to include examples for creating and reading.")
    

    Method 2: Accessing Notes via Database (macOS Only)

    Apple Notes does not have good AppleScript support for reading content. The most effective way is to read its local SQLite database directly.

    ⚠️ Disclaimer: This is an undocumented, private database. Its structure can and will change without warning in future macOS updates, which could break your script. Use this with caution.

    import sqlite3
    import os
    import zlib
    from html import unescape
    
    def get_apple_notes():
        """
        Reads notes directly from the Apple Notes SQLite database on macOS.
        
        Returns:
            A list of dictionaries, where each dictionary represents a note
            with 'title', 'folder', and 'content' keys.
        """
        # Path to the SQLite database
        # Note: This path is for modern macOS versions.
        db_path = os.path.expanduser('~/Library/Group Containers/group.com.apple.notes/NoteStore.sqlite')
        
        if not os.path.exists(db_path):
            print("Error: Apple Notes database not found.")
            return []
    
        conn = sqlite3.connect(db_path)
        cursor = conn.cursor()
        
        # Query to get note title, folder name, and the compressed content
        # This query joins the main note table with the folder and body tables
        query = """
        SELECT
            n.ZTITLE1,
            f.ZTITLE2,
            b.ZDATA
        FROM
            ZNOTE AS n
        LEFT JOIN
            ZNOTEBODY AS b ON b.ZOWNER = n.Z_PK
        LEFT JOIN
            ZFOLDER AS f ON n.ZFOLDER = f.Z_PK
        WHERE
            n.ZTRASHED = 0;
        """
        
        notes = []
        try:
            cursor.execute(query)
            for row in cursor.fetchall():
                title, folder, zdata = row
                
                content = ""
                if zdata:
                    try:
                        # Decompress the zlib-compressed data
                        # The first few bytes are a header, so we skip them
                        decompressed_data = zlib.decompress(zdata, wbits=-15)
                        # The actual text is often found after a specific marker or at the start
                        # This is fragile and may need adjustment. We'll find the first printable text.
                        # A more robust method would involve parsing the protobuf format inside.
                        # For this example, we'll do a simple decode.
                        content = unescape(decompressed_data.decode('utf-8', errors='ignore'))
                        # This is a very rough way to clean it up; real content is complex
                        content = ' '.join(content.split()) 
                    except Exception as e:
                        content = f"[Could not decompress content: {e}]"
                
                notes.append({
                    "title": title,
                    "folder": folder if folder else "Notes", # Default folder name
                    "content": content
                })
    
        except sqlite3.OperationalError as e:
            print(f"Error querying database (schema might have changed): {e}")
        finally:
            conn.close()
            
        return notes
    
    # --- Example Usage ---
    if __name__ == "__main__":
        all_notes = get_apple_notes()
        if all_notes:
            print(f"Found {len(all_notes)} notes.")
            # Print the first 5 notes
            for note in all_notes[:5]:
                print("-" * 20)
                print(f"Folder: {note['folder']}")
                print(f"Title: {note['title']}")
                # print(f"Content Preview: {note['content'][:100]}...") # Uncomment for content
    

    Method 3: Third-Party Library pyicloud (Cross-Platform)

    This library works by simulating a web browser to log into iCloud.com.

    ⚠️ Security Warning: This method requires you to provide your Apple ID and password to the script. This is a significant security risk. It is highly recommended to generate an app-specific password from the Apple ID website to use instead of your main password.

    1. Install the library:
      pip install pyicloud
      
    2. Generate an App-Specific Password:
      • Go to appleid.apple.com.
      • Sign in and navigate to "App-Specific Passwords" under Sign-In and Security.
      • Generate a password and use it in the script below.

    Example Script using pyicloud

    from pyicloud import PyiCloudService
    import sys
    import getpass
    
    # --- Configuration ---
    # It's better to use environment variables or a secure vault for credentials
    APPLE_ID = "your-apple-id@example.com"
    # Leave password blank to be prompted securely
    APP_SPECIFIC_PASSWORD = "" 
    
    # Initialize the API
    try:
        if not APP_SPECIFIC_PASSWORD:
            APP_SPECIFIC_PASSWORD = getpass.getpass(f"Enter app-specific password for {APPLE_ID}: ")
            
        api = PyiCloudService(APPLE_ID, APP_SPECIFIC_PASSWORD)
    except Exception as e:
        print(f"Error initializing iCloud service: {e}")
        sys.exit(1)
    
    # Handle Two-Factor Authentication (2FA)
    if api.requires_2fa:
        print("Two-factor authentication required.")
        code = input("Enter the code you received on your device: ")
        result = api.validate_2fa_code(code)
        print("Code validation result: %s" % result)
        
        if not result:
            print("Failed to verify 2FA code.")
            sys.exit(1)
            
        if not api.is_trusted_session:
            print("Session is not trusted. Requesting trust...")
            api.trust_session()
    
    # --- Access Reminders ---
    print("\n--- Reminders ---")
    try:
        for list_name, reminder_list in api.reminders.lists.items():
            print(f"\nList: {list_name}")
            for task in reminder_list.tasks:
                 # task is a dictionary
                title = task.get('title', 'No Title')
                if not task.get('completedDate'):
                    print(f"- {title}")
    except Exception as e:
        print(f"Could not fetch reminders: {e}")
    
    # --- Access Notes ---
    print("\n--- Notes ---")
    try:
        # `fetch_notes` re-syncs with the server
        api.notes.fetch_notes()
        for i, note in enumerate(api.notes.notes):
            # note is a dictionary-like object
            print(f"\nNote {i+1}: {note.title}")
            print(f"Content Preview: {note.content.strip()[:100]}...")
    except Exception as e:
        print(f"Could not fetch notes: {e}")
    

    My Recommendation

    • On macOS: Use Method 1 (AppleScript) for Reminders as it's the most stable. For Notes, use Method 2 (Database Access) but build your script defensively, knowing it might break.
    • On Windows/Linux: Your only real option is Method 3 (pyicloud). Be very careful with your credentials and always use an app-specific password.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.