# How to Connect Apple Notes to OpenClaw

- Tool: OpenClaw
- Difficulty: Intermediate
- Time required: 20 minutes
- Last updated: March 2026

## TL;DR

To connect Apple Notes to OpenClaw on macOS, configure OpenClaw to run AppleScript or JXA (JavaScript for Automation) commands that interact with the Notes app directly. No API key is needed — OpenClaw uses macOS automation to create, read, and search notes in any Apple Notes account or folder. This integration requires macOS and works with the Notes app that ships with every Mac.

## Why Connect Apple Notes to OpenClaw on macOS?

Apple Notes is one of the most widely used note-taking apps on macOS because it is built in, free, syncs instantly with iPhone and iPad via iCloud, and supports rich content including images, tables, checklists, and attachments. For users who live in the Apple ecosystem, it is often the fastest place to capture thoughts — faster than opening a web app or standalone tool.

Connecting OpenClaw to Apple Notes means your AI agent can work with your existing notes without requiring you to migrate to a different note-taking tool. OpenClaw can create structured notes from research tasks, search your existing notes for relevant context, append meeting summaries to existing notes, and organize notes into folders — all using macOS's built-in automation framework.

The integration uses AppleScript (or its modern JavaScript equivalent, JXA), which is the standard macOS mechanism for automating native app behavior. The key thing to understand is that Apple Notes stores content as HTML internally — not plain text or Markdown. When OpenClaw reads a note, it gets the raw HTML body. When creating notes, you can pass HTML for rich formatting or plain text for simple content. This is different from Obsidian or Bear Notes, which use plain Markdown, but it allows OpenClaw to create notes with bold text, bullet lists, checkboxes, and other formatting Apple Notes supports.

## Before you start

- A Mac running macOS 12 (Monterey) or later with the Notes app installed and configured
- OpenClaw installed on the same Mac
- macOS Automation permissions — you will need to allow OpenClaw (specifically the `osascript` command) to control the Notes app in System Settings
- An iCloud account logged in on the Mac if you want notes to sync to iPhone/iPad (optional — local notes work without iCloud)
- No API key or developer account required for this integration

## Step-by-step guide

### 1. Grant macOS Automation Permissions to OpenClaw

Apple Notes automation via AppleScript requires explicit macOS permission. When OpenClaw (or osascript) first attempts to control the Notes app, macOS will show a permission dialog asking whether to allow automation. You must approve this for the integration to work.

To pre-grant permission: open System Settings > Privacy & Security > Automation. Look for Terminal, OpenClaw, or the relevant application in the list. Ensure that 'Notes' is checked as an allowed target app.

If the permission dialog never appeared, try running the test AppleScript command below manually from Terminal first — this triggers the permission request. Once you approve it in Terminal, OpenClaw (which also uses osascript under the hood) inherits the permission.

On macOS 14 (Sonoma) and later, automation permissions are managed per-app. If OpenClaw runs as its own process (not via Terminal), it may need a separate permission grant. Check System Settings > Privacy & Security > Automation after running OpenClaw for the first time.

```
# Test AppleScript access to Notes from Terminal (triggers permission dialog)
osascript -e 'tell application "Notes" to get name of every account'
# Expected output: {"iCloud", "On My Mac"} or similar
# If you get a permission error, approve it in System Settings

# Check if Notes automation permission is granted:
osascript -e 'tell application "Notes" to get name of first note of first account'
# Should return the name of your first note — confirms read access is working
```

**Expected result:** Running the test osascript commands in Terminal returns note names without permission errors. The permission dialog has been approved.

### 2. Configure Apple Notes Integration in OpenClaw

Open your OpenClaw config file at `~/.openclaw/config.yaml` and add the Apple Notes integration under the `integrations` key. Because Apple Notes uses osascript for all operations, the config specifies which AppleScript commands to run for each operation type.

The `account` field specifies which Notes account to use. Apple Notes can have multiple accounts (iCloud, On My Mac, Exchange). Use `iCloud` for cloud-synced notes that appear on iPhone/iPad, or `On My Mac` for local-only notes.

The `default_folder` specifies which folder new notes are created in by default. If the folder does not exist, OpenClaw will create it using AppleScript. Leave it empty to create notes in the root of the account.

Note that OpenClaw's Notes integration uses osascript internally — it constructs and runs AppleScript commands based on the operations you request. The config examples show the underlying AppleScript patterns for reference, but OpenClaw handles the script construction automatically.

```
# ~/.openclaw/config.yaml
integrations:
  apple-notes:
    account: "iCloud"           # 'iCloud' or 'On My Mac'
    default_folder: "OpenClaw"  # default folder for new notes (created if missing)
    content_format: "html"      # 'html' or 'plaintext' for note body (default: plaintext)
    include_creation_date: true # add creation date to note body (default: true)
    search_limit: 20            # max notes to return in search results (default: 10)

# AppleScript patterns used internally by OpenClaw:
# Create note:
# tell application "Notes"
#   tell account "iCloud"
#     make new note at folder "OpenClaw" with properties {name: "Title", body: "Content"}
#   end tell
# end tell
#
# Search notes:
# tell application "Notes"
#   tell account "iCloud"
#     notes whose name contains "keyword" or body contains "keyword"
#   end tell
# end tell
```

**Expected result:** `clawhub reload` runs without errors and the apple-notes integration is registered in OpenClaw's config.

### 3. Test Creating and Reading Notes

Test the integration by creating a note and then reading it back. The create test verifies that OpenClaw can run AppleScript to create a note in the configured account and folder. The read test confirms that search and retrieval work correctly.

Apple Notes stores note content as HTML. When you pass plain text to the create operation, OpenClaw wraps it in basic HTML tags before sending to AppleScript. When you read a note, the body will be returned as HTML — you may see `<div>`, `<br>`, and `<p>` tags in the raw output. OpenClaw's integration layer strips basic HTML tags for plain-text output modes.

For formatted notes with checklists, you need to use the specific HTML structure Apple Notes expects for checklist items. The code sample below shows the correct format for creating notes with checklists, which is useful for task tracking workflows.

```
# Test creating a note via AppleScript (run in Terminal to test before OpenClaw):
osascript <<'EOF'
tell application "Notes"
  tell account "iCloud"
    -- Create folder if it doesn't exist
    if not (exists folder "OpenClaw") then
      make new folder with properties {name: "OpenClaw"}
    end if
    -- Create the test note
    make new note at folder "OpenClaw" with properties {¬
      name: "OpenClaw Test Note", ¬
      body: "<div><b>Test note</b> created by OpenClaw.</div><div><br></div><div>Integration is working correctly.</div>"}
  end tell
end tell
EOF

# Test searching notes:
osascript <<'EOF'
tell application "Notes"
  tell account "iCloud"
    set matchingNotes to notes whose name contains "OpenClaw"
    set noteNames to {}
    repeat with n in matchingNotes
      set end of noteNames to name of n
    end repeat
    return noteNames
  end tell
end tell
EOF
```

**Expected result:** A new note titled 'OpenClaw Test Note' appears in the OpenClaw folder in Apple Notes. The search command returns the note name. The note syncs to your iPhone/iPad within a few seconds if using iCloud.

### 4. Build Note Automation Workflows

With the connection verified, configure OpenClaw workflows that automate Apple Notes creation. The workflow patterns are similar to Obsidian workflows but use AppleScript operations instead of filesystem writes.

For meeting notes, the workflow triggers on a keyword command (e.g., 'meeting:') and creates a structured HTML note with sections for date, attendees, decisions, and action items. The HTML formatting ensures the note looks good in Apple Notes with proper heading styles and bullet lists.

For the daily summary workflow, OpenClaw checks whether today's note already exists (using a date-prefixed search) and either creates a new one or appends a new section. Apple Notes' AppleScript API supports modifying the `body` property of an existing note, which replaces the entire body — so 'append' operations read the existing body, add the new content, and write the combined result back.

RapidDev's team has found that for high-frequency append workflows (10+ writes per day), batching the appends and writing once at session end is more reliable than writing on every event — this reduces the chance of AppleScript race conditions if multiple OpenClaw workflows run simultaneously.

```
# ~/.openclaw/config.yaml — Apple Notes automation workflows
workflows:
  meeting-notes:
    trigger:
      type: chat-message
      pattern: "^meeting: (.+)"
    actions:
      - type: apple-notes-create
        integration: apple-notes
        folder: "Meetings"
        title: "Meeting — {{date:YYYY-MM-DD}} — {{trigger.match.1}}"
        body_html: |
          <div><b>Date:</b> {{date:MMMM D, YYYY}}</div>
          <div><b>Topic:</b> {{trigger.match.1}}</div>
          <div><br></div>
          <div><b>Attendees:</b></div>
          <div><br></div>
          <div><b>Decisions:</b></div>
          <div><br></div>
          <div><b>Action Items:</b></div>
          <div><br></div>
          <div><i>Created by OpenClaw</i></div>

  daily-summary:
    trigger:
      type: session-end
    actions:
      - type: apple-notes-append-or-create
        integration: apple-notes
        folder: "OpenClaw Logs"
        title: "OpenClaw Log — {{date:YYYY-MM-DD}}"
        append_html: |
          <div><br></div>
          <div><b>Session at {{time:HH:mm}}</b></div>
          <div>Tasks: {{session.task_count}}</div>
          <div>{{session.summary}}</div>
```

**Expected result:** OpenClaw creates structured Apple Notes entries based on workflow triggers. Notes appear in the correct folders, sync to iPhone/iPad via iCloud, and have proper HTML formatting in Apple Notes.

## Best practices

- Pre-grant Automation permissions by running a test AppleScript from Terminal before deploying OpenClaw workflows — this ensures permissions are in place before automated workflows attempt to write notes and fail silently.
- Use HTML body format for notes with structured sections (headings, lists, checkboxes) and plaintext format for simple log entries — Apple Notes renders HTML correctly and plaintext notes look cleaner for simple content.
- Target the iCloud account for notes that need to sync to iPhone/iPad, and 'On My Mac' for local-only notes that should never leave the Mac — be intentional about which account you use for sensitive notes.
- Keep note titles concise and include the date for any time-sensitive logs — Apple Notes does not sort by creation date in older macOS versions, so date-prefixed titles (e.g., '2026-03-30 Meeting Notes') keep your folder organized chronologically.
- Avoid running multiple simultaneous OpenClaw workflows that write to the same note — AppleScript operations are not atomic and concurrent writes can corrupt the note body. Use a queue or batch writes at session end.
- Create a dedicated 'OpenClaw' or 'AI Logs' folder in Apple Notes for all automatically generated notes — this keeps them separate from your manually written notes and makes it easy to review or delete them in bulk.
- Test note creation with the Notes app open in Obsidian — watch the file tree to confirm notes appear in the correct folder in real time. This is faster than checking iCloud sync on a second device.

## Use cases

### Create Structured Meeting Notes Automatically

After a voice or text meeting summary is given to OpenClaw, automatically create a new Apple Notes entry in a designated 'Meetings' folder with structured sections for agenda, decisions, and action items. The note syncs to iPhone and iPad instantly via iCloud, making it accessible everywhere.

Prompt example:

```
Build an OpenClaw workflow that creates a new Apple Notes note in the 'Meetings' folder when triggered with meeting content, formatted with sections for Date, Attendees, Decisions, and Next Steps
```

### Search Notes for Context Before Responding

Before OpenClaw responds to a question, search Apple Notes for relevant existing context — prior research, saved articles, or personal notes on the topic. This allows OpenClaw to incorporate your personal knowledge base when forming responses, not just general AI knowledge.

Prompt example:

```
Configure OpenClaw to search my Apple Notes for notes containing a given keyword before answering questions on that topic, and include any relevant findings in the response context
```

### Daily Summary Note to Apple Notes

At the end of each OpenClaw session, automatically create or update a daily note in Apple Notes summarizing the session's tasks, searches, and outputs. The note is created in an 'OpenClaw Logs' folder and syncs to all Apple devices immediately via iCloud.

Prompt example:

```
Set up OpenClaw to create a daily Apple Notes entry in the 'OpenClaw Logs' folder after each session, listing all completed tasks with timestamps and any important outputs
```

## Troubleshooting

### osascript returns 'Not authorized to send Apple events to Notes' or permission error

Cause: macOS Automation permissions have not been granted, or the permission was revoked after a macOS update or system preferences reset.

Solution: Open System Settings > Privacy & Security > Automation. Find Terminal (or the OpenClaw app entry if it runs standalone) and ensure 'Notes' is checked. If the entry is not there, run `osascript -e 'tell application "Notes" to count notes'` from Terminal to trigger the permission dialog, then approve it.

```
# Reset and re-grant Automation permissions if needed:
# 1. System Settings > Privacy & Security > Automation
# 2. Remove the Terminal entry (click the minus button)
# 3. Run this command to re-trigger the permission dialog:
osascript -e 'tell application "Notes" to get name of every account'
```

### Notes are created in the wrong account or folder

Cause: The `account` field in OpenClaw's config does not match an existing account name in Apple Notes, or the `default_folder` path is wrong.

Solution: List your Notes accounts by running `osascript -e 'tell application "Notes" to get name of every account'` in Terminal. The output shows the exact account names to use (e.g., `iCloud`, `On My Mac`). Use the exact name, including capitalization, in your OpenClaw config.

```
# List all Notes accounts:
osascript -e 'tell application "Notes" to get name of every account'
# Output: {"iCloud", "On My Mac"}

# List folders in an account:
osascript -e 'tell application "Notes" to tell account "iCloud" to get name of every folder'
```

### OpenClaw errors with 'apple-notes integration not available on this platform'

Cause: OpenClaw's Apple Notes integration requires macOS — it uses osascript, which is not available on Windows or Linux.

Solution: Apple Notes integration only works on macOS. If you need cross-platform notes integration, use the Notion, Obsidian (local vault), or Google Sheets integration instead. On macOS, verify OpenClaw is running as a native process (not inside a Docker container or WSL environment where osascript is unavailable).

### Note body contains visible HTML tags when viewed in Apple Notes

Cause: The `content_format` is set to `html` but the note body contains improperly escaped HTML, or plaintext content with HTML special characters was passed without proper escaping.

Solution: For plaintext content, set `content_format: plaintext` in the config. For HTML content, ensure angle brackets in the note body content (not structure tags) are escaped as `&lt;` and `&gt;`. Verify that OpenClaw's HTML template uses proper `<div>` and `<br>` tags rather than raw newlines.

```
# Use plaintext format to avoid HTML issues:
# In ~/.openclaw/config.yaml:
integrations:
  apple-notes:
    content_format: "plaintext"  # no HTML encoding issues

# Or escape special chars in HTML body:
# < becomes &lt;   > becomes &gt;   & becomes &amp;
```

## Frequently asked questions

### How do I set up Apple Notes integration in OpenClaw?

Configure `integrations.apple-notes` in `~/.openclaw/config.yaml` with the Notes account name (`iCloud` or `On My Mac`) and a default folder. Grant macOS Automation permissions by running a test AppleScript from Terminal first. No API key is needed — OpenClaw uses osascript to control the Notes app directly.

### Does the OpenClaw Apple Notes integration work on iPhone or iPad?

No — the integration uses macOS AppleScript (osascript), which only runs on Mac. However, notes created by OpenClaw via the iCloud account will automatically sync to your iPhone and iPad through iCloud. You create notes on Mac via OpenClaw and access them on iOS devices through normal iCloud sync.

### Why is Apple Notes automation macOS-only?

Apple Notes has no public REST API. The only programmatic access to Apple Notes is through macOS's AppleScript and JXA automation frameworks, which are built into macOS but are not available on Windows, Linux, or iOS. For cross-platform notes integration, use Notion or Obsidian instead.

### Can OpenClaw read and search existing Apple Notes?

Yes — OpenClaw's Apple Notes integration supports searching notes by title or body keyword, reading the full content of specific notes, and listing all notes in a folder. Note content is returned as HTML (Apple Notes' native format), which OpenClaw can process or strip to plain text depending on your workflow.

### What happens to Apple Notes integration after a macOS update?

macOS updates occasionally reset Automation permissions. If OpenClaw's Notes integration stops working after a system update, check System Settings > Privacy & Security > Automation and re-grant permission for Terminal or the OpenClaw app to control Notes. Running the test osascript command from Terminal again will prompt for re-approval if permissions were revoked.

### Can RapidDev help set up Apple Notes workflows in OpenClaw?

Yes — RapidDev can help configure OpenClaw workflows for Apple Notes including meeting note templates, daily journal automation, and note search integrations. Contact RapidDev if you need AppleScript-based workflows that go beyond basic note creation, such as nested folder management or note sharing workflows.

---

Source: https://www.rapidevelopers.com/openclaw-integrations/apple-notes
© RapidDev — https://www.rapidevelopers.com/openclaw-integrations/apple-notes