Guide · 4 min read

Boox notes into your memory

Export your e-ink notes as text or Markdown, then script them into Petals — or skip the script entirely and paste them in.

2026-06-11

Before you start

There is no native Boox connector. To script ingestion, create an API key at Settings → API keys in the app — every key starts with petals-. Set it in your environment before running any script:

bash

export PETALS_API_KEY="petals-yourkey..."

If you just want to move a handful of notes, the zero-script path described at the end is the right one.

Why Boox notes are worth ingesting

Boox tablets produce a kind of writing that rarely makes it into a searchable system. The margin annotations, the quick sketches turned into typed notes, the reading highlights from an article you marked up on the subway — these live in the device's sync folder and nowhere else. Once they reach Petals, your assistants can draw on them: they surface as claims in your memory graph, attributed to the text, with the original document as their source. Ask what you were thinking about in March and the answer might come from a note you scribbled on a commute.

Petals sees them the same way it sees any document: text goes in, an extraction job runs in the background, and the ideas land in the graph. The source stays attached so you can always trace a claim back to the page it came from.

How Boox exports work

Boox tablets sync notes to a folder — either via Boox's cloud service or a local sync app on your computer. The output is plain text or Markdown, one file per note. A typical setup leaves new files in a folder like ~/Boox/MyNotes/ or ~/OneDrive/Boox/. That folder is what the script below watches.

PDF exports are also possible from the Boox interface. PDFs work fine in the file upload UI (the File tab in the Add to Memory dialog accepts PDF up to 10 MB), but they are harder to script because file ingestion over REST is not yet exposed as a public endpoint — the document endpoint expects inline text. For scripting, stick with the text or Markdown export.

The scripted pattern

The document ingestion endpoint accepts a content string and returns a job ID. The job runs asynchronously in the background — you get confirmation immediately, and the extraction reaches your graph minutes later.

Endpoint: POST /api/memory/ingest/document

Payload shape (verbatim from the ingestion API):

json

{
  "document": {
    "id": "boox-note-2026-06-11-my-note",
    "content": "The full text of the note...",
    "contentType": "markdown",
    "title": "My note",
    "scope": "personal",
    "timestamp": "2026-06-11T09:00:00Z"
  }
}

The id field is yours to manage. A stable, deterministic ID (based on the filename and its modification date, for example) lets you set updateExisting: true and re-run the script safely — the same note will replace itself rather than create a duplicate.

Example script (~20 lines, Node.js):

// boox-sync.js — a pattern to adapt
// Create your API key at Settings → API keys, then set PETALS_API_KEY.
import { readFileSync, readdirSync, statSync } from "fs";
import { basename, extname, join } from "path";

const API_KEY = process.env.PETALS_API_KEY; // set in your shell
const PETALS_URL = "https://petals.chat";
const NOTES_DIR = process.env.BOOX_NOTES_DIR; // e.g. ~/Boox/MyNotes

for (const filename of readdirSync(NOTES_DIR)) {
  if (![".md", ".txt"].includes(extname(filename))) continue;
  const filepath = join(NOTES_DIR, filename);
  const content = readFileSync(filepath, "utf8");
  const mtime = statSync(filepath).mtime.toISOString();
  const id = `boox-${basename(filename, extname(filename))}-${mtime.slice(0, 10)}`;

  const res = await fetch(`${PETALS_URL}/api/memory/ingest/document`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "x-api-key": API_KEY,
    },
    body: JSON.stringify({
      updateExisting: true,
      document: {
        id,
        content,
        contentType: "markdown",
        title: filename,
        scope: "personal",
        timestamp: mtime,
      },
    }),
  });

  const { jobId } = await res.json();
  console.log(`queued ${filename} → job ${jobId}`);
}

Run it once manually, verify a note arrives in your memory graph, then wire it to a cron job or a folder-watch script. A daily run is usually enough — Boox notes are not a real-time feed.

What happens after ingestion

The job ID in the response tells you the extraction is queued. Within a few minutes, the memory service has read the note, pulled out entities and claims, and added them to your graph. You can verify in the memory explorer: open a source node and you will see the claims extracted from it, each one traceable back to the original text.

Notes ingested with scope: "personal" are searchable in your personal memory and surface in assistant answers. If you are ingesting reference material — an annotated paper, a book's highlights — set scope: "reference" instead.

The zero-script alternative

If you have a few notes to move and no appetite for a script right now, the simplest path is to export a note from Boox as plain text, open the Add to Memory dialog in Petals, paste the text into the Note tab, add a title and the date, and save. The result is identical to what the script produces. There is nothing wrong with doing it this way. The script matters when you have dozens of notes or want the habit to be invisible.

For PDF exports — say, a whole annotated book — the File tab in the same dialog accepts the file directly. Drag it in, give it a title, and let the extraction run. No script required.

Where this pattern goes

The script above is intentionally minimal. You could extend it to deduplicate by file hash rather than modification date, to skip notes shorter than a threshold, to tag exports from a particular device as a different scope, or to pull from Boox's cloud API directly instead of a synced folder. The endpoint contract is stable; the auth mechanism is settled.

If you want to pipe Boox notes through an assistant first — summarize them, extract action items, reformat your highlights before they land in the graph — the same endpoint accepts that processed text. Ingestion does not require the raw original; it works just as well with a cleaned, structured version of what you wrote.