How Notion copies
text and HTML.

Where does the copy operation go?

The page sees a method called clipboard.write. Its implementation in the preload is a wrapper. The useful question is what that wrapper sends, and which code receives it.

An example prompt with Notion's local application package available to your coding agent.

REA finds where to start reading

Analyzing the tab preload with REA locates the API exposed to the page and the call that sends an IPC request. Both findings come with source ranges in the minified bundle:

api_key: "__electronApi"
api_status: "dynamic"
source: preload.js:1:22764–22828

operation: "invoke"
channel_expression: "e"
source: preload.js:1:6486–6522

The agent opens those locations, finds the clipboard member in the assembled API, and reads invokerInMain. Its call site supplies notion:clipboard:write. That name gives the agent something precise to look for in the main bundle. The four excerpts below show the route it connects.

Four short pieces of code

Simplified from the packaged JavaScript, with readable variable names. Unrelated members are omitted.

1. Start at the API exposed to the page

   tab_browser_view/preload.js · API member Copy

   const clipboardApi = {
     write: invokerInMain("notion:clipboard:write")
   };
   
   // Included in the API exposed through contextBridge:
   // window.__electronApi.clipboard

   This member supplies the channel name. The implementation of invokerInMain tells us how the request leaves the page's process.

2. Resolve the preload's wrapper

   tab_browser_view/preload.js · IPC helper Copy

   function invokerInMain(channel) {
     return (...args) => invokeInMainAndReturnResult(channel, ...args);
   }
   
   function invokeInMainAndReturnResult(channel, ...args) {
     return ipcRenderer.invoke(channel, ...args);
   }

   The returned function forwards the arguments through Electron's request-and-response IPC. We can now look for notion:clipboard:write on the main-process side.

3. Check how the receiver is registered

   main/index.js · handler helper Copy

   const handleRequestFromRenderer = {
     addListener(channel, handler) {
       ipcMain.handle(channel, handler);
     }
   };

   The main process uses another wrapper. Its addListener method registers an ipcMain.handle receiver for that channel.

4. Find the write and its sender check

   main/index.js · clipboard receiver Copy

   handleRequestFromRenderer.addListener(
     "notion:clipboard:write",
     (event, data) =>
       isNotionWebContents(event.sender)
         ? clipboard.write(data)
         : undefined
   );

   This is the destination. After checking the sender, the handler passes the supplied data to Electron's clipboard API. The channel and the two resolved wrappers connect the exposed method to this call.

How does a copied block keep its structure?

Notion's web editor sends text and HTML through electronApi.clipboard.write. It keeps the block data locally and puts an ID in the copied HTML to connect them.

text: "Project notes"
html: "<p>Project notes</p>"
    + "<!-- notionvc: <copy-id> -->"

id: <copy-id>
mimeTypes:
  text/_notion-blocks-v3-production
    → structured block data

On paste, Notion looks for the HTML ID and checks it against the saved copy. Matching IDs restore the block data.

Clipboard format recorded from web assets cached on July 13, 2026.

More examples and sources

| A | B |
| - | - |
| 1 | 2 |

table · headerRow: true
  table_row
    cells: ["A"], ["B"]
  table_row
    cells: ["1"], ["2"]

• JavaScript application guideFollow a small Electron application's export feature.
• DX-Ball reconstructionFollow native instructions to a checked C function.