Capturing content

Every capture path produces the same thing: an immutable source in raw/<id>/ that Anthracite then processes into your wiki and tasks. This page covers each path that ships today, with concrete steps and copy-pasteable examples.

Find your port first. The local HTTP routes below (/v1/ingest, /v1/webhook/...) live on the backend's loopback port. When you run from source the port is 5050. In the packaged app the backend picks a private loopback port, so always read the actual values from Settings → Developer — it shows the exact Endpoint, Port, Bearer token, and Webhook URL for the running vault. The examples below use 5050; substitute your port.

Quick chooser

Folder watch

Point Anthracite at a directory; new files (.md, .txt, .pdf, images, audio) are copied into raw/ and processed. core-service owns folder watch in-process (FolderWatchSyncService); the legacy sync-service process is not auto-started (see RUNNING.md).

• Drag-and-drop: drop files straight onto the app window — they land in raw/ immediately.
• Inbox: drop files into your vault's raw/inbox/ folder (enabled by default).
• Voice memos: drop audio into raw/inbox/audio/ — see Settings → Voice.
• Watch extra folders: open Settings → Connections → Folder watch to enable the watcher, toggle the inbox, and add absolute paths to other directories on this Mac. Click Sync now to ingest files already sitting in watched folders.

No API key. Files are hash-deduplicated, so re-dropping the same file won't create duplicates.

Obsidian (ingest-only)

Watch an existing Obsidian vault and import its Markdown into Anthracite. This is ingest-only: Anthracite reads your Obsidian notes into its own raw/ → wiki/ pipeline and never writes back into your Obsidian vault.

1. Open Settings → Connections → Obsidian.
2. Set Obsidian vault folder to the absolute path of your vault (e.g. /Users/you/Documents/My Vault).
3. Enable it (and Auto-sync if you want it to keep watching).

Frontmatter and [[wikilinks]] are preserved. Anthracite automatically skips its own wiki/, raw/, and Obsidian's .obsidian/ folders so nothing loops back on itself.

Apple Notes

Import your Apple Notes — read directly from the Notes database on this Mac, nothing goes through a server or iCloud API.

1. Open Settings → Connections → Apple Notes.
2. Grant Full Disk Access when prompted: macOS protects the Notes database, so Anthracite can't read it without this. The card links straight to System Settings → Privacy & Security → Full Disk Access; toggle Anthracite on there, then come back.
3. Click Sync now. Optionally enable Auto-sync (5/10/15/30/60 min).

What comes across:

• All non-deleted notes with a title, from all accounts and folders. Sync is incremental — only new/changed notes on later runs.
• Text formatting is preserved as Markdown: headings, lists, checklists, and embedded tables.
• Folder, account, pinned state, and #hashtags are kept as metadata.

Current limits:

• Attachments and images aren't imported — they show as placeholders in the extracted text.
• Password-protected notes are skipped (Anthracite can't decrypt them, by design).
• Apple Notes sources are not processed automatically by default — sync brings them in as pending sources, and you process the ones worth keeping (or add apple-notes to your auto-ingest connectors).

If sync fails with a "Notes database is busy" message, quit the Apple Notes app and retry.

Voice memos

Drop audio files and get transcripts — transcription runs locally via Whisper; audio never leaves your Mac.

• Where: drop .m4a, .mp3, or .wav files into your vault's raw/inbox/audio/ folder (or drag them onto the app window).
• Engine: configured in Settings → Voice — faster-whisper (default), openai-whisper, or whisper.cpp, plus the model size (default base). The Whisper binary must be installed on your Mac; the Settings card shows what it's looking for and how to install it.
• The transcript (with timestamps, detected language, and duration) becomes the source's extracted.md, which is processed like any other note — so "remind me to book the dentist" spoken into a memo ends up on your Board.

There's no in-app microphone recording (yet) — record with Voice Memos or any recorder, then drop the file. A tip for iPhone users: a two-step Apple Shortcut can save Voice Memos into the watched folder automatically.

Browser clipper

A Manifest V3 browser extension (Chrome/Edge/Brave, plus a best-effort Firefox build) that pushes web clips into your local vault via the local ingest API. Nothing leaves your machine — clips go straight to the desktop app over 127.0.0.1.

It offers three actions: Clip selection (highlighted text), Clip page (reader mode) (main article via Readability), and Clip URL only (title + link).

Install (load unpacked)

The extension ships unpacked (web-store signing is a later step).

Chrome / Edge / Brave

1. Build it: pnpm --filter @anthracite/clipper build (output in apps/clipper/dist/).
2. Open chrome://extensions.
3. Toggle Developer mode (top-right).
4. Click Load unpacked and select apps/clipper/dist/.

Firefox

1. Build it: pnpm --filter @anthracite/clipper build:firefox.
2. Open about:debugging#/runtime/this-firefox.
3. Click Load Temporary Add-on… and pick apps/clipper/dist/manifest.json (removed when Firefox restarts).

Configure the token + port

1. In the desktop app, open Settings → Developer → Local ingest API.
2. Copy the Bearer token and the Port (or the full Endpoint URL).
3. Open the extension's Options page (popup → Options).
4. Paste the token. In Endpoint or port, paste either the full endpoint (http://127.0.0.1:5050/v1/ingest), the origin (http://127.0.0.1:5050), or just the bare port (5050) — all are accepted.
5. Optionally set Tags applied to every clip (comma-separated).
6. Click Save, then Test connection.

Settings are stored only in that browser. Each vault has its own token, so switching vaults means re-pasting the token here.

Local ingest API

A loopback HTTP endpoint for pushing content from scripts or your own tools. It's the same route the browser clipper uses.

• Route: POST http://127.0.0.1:<port>/v1/ingest
• Auth: Authorization: Bearer <token> (required)
• Body (JSON): { "title"?, "text"?, "html"?, "url"?, "tags"? } — needs at least a non-empty title or text/html.
• Response: { "sourceId": "...", "autoCompiled": true|false } (autoCompiled reflects whether your vault's auto-ingest policy processed it immediately).

Get the token and port from Settings → Developer → Local ingest API.

curl -X POST http://127.0.0.1:5050/v1/ingest \
  -H "Authorization: Bearer YOUR_TOKEN_HERE" \
  -H "Content-Type: application/json" \
  -d '{
        "title": "Distillation notes",
        "text": "Knowledge distillation transfers behavior from a large teacher model to a small student.",
        "url": "https://example.com/article",
        "tags": ["ml", "reading"]
      }'

Errors you might see:

• 401 Unauthorized — missing/wrong token.
• 400 — body isn't a JSON object, or has neither title nor text/html.

Security. Anyone with this token + port can write to your vault. The token lives in the vault's .anthracite/state.json and never leaves your machine. Rotate it any time with Regenerate token in Settings → Developer (which invalidates the old one — update your clipper/scripts after).

Webhook

A loopback webhook URL for automations that can POST but can't set custom headers — Apple Shortcuts, Zapier, IFTTT, etc. Authentication is carried by a per-vault secret in the URL path instead of a header.

• Route: POST http://127.0.0.1:<port>/v1/webhook/<secret>
• Auth: the <secret> path segment (no header needed)
• Body: JSON { "title"?, "text"|"body"|"content", "url"?, "tags"? }, or a text/plain body (the whole text becomes the source). Header-less senders work too. Some text content is required.
• Response: { "sourceId": "...", "autoCompiled": true|false }

Get the full Webhook URL (port + secret already filled in) from Settings → Developer → Webhook ingest.

JSON example:

curl -X POST "http://127.0.0.1:5050/v1/webhook/YOUR_SECRET_HERE" \
  -H "Content-Type: application/json" \
  -d '{ "title": "Idea", "text": "Ship the weekly digest as an email.", "tags": ["ideas"] }'

Plain-text example (e.g. an Apple Shortcut posting raw text):

curl -X POST "http://127.0.0.1:5050/v1/webhook/YOUR_SECRET_HERE" \
  -H "Content-Type: text/plain" \
  --data "Quick thought I want processed later."

Notes:

• Because the backend binds loopback (127.0.0.1), senders on this Mac (like Apple Shortcuts) work out of the box. Remote senders (Zapier in the cloud) need a tunnel to reach your machine — an always-on hosted variant is a future Anthracite Cloud feature.
• The body field is flexible: text, body, or content are all accepted (first non-empty wins). If you omit title, the first line of the text is used.
• A wrong/missing secret returns 401. Treat the URL like a password; rotate it with Regenerate webhook URL in Settings → Developer.

reMarkable

Sync notebooks, PDFs, and handwritten pages from your reMarkable tablet; the .rm pages are rendered to page previews and read into extracted.md.

1. Open Settings → Connections → reMarkable.
2. Go to my.remarkable.com/device/desktop/connect and generate a one-time 8-character code.
3. Enter the code in Anthracite to link the device.
4. Pick the notebooks to sync — it's an allowlist (with search/sort), so your grocery-list notebook doesn't have to become knowledge.
5. Sync manually, or enable Auto-sync (5/10/15/30/60 min).

Notes on behavior:

• What syncs: handwritten notebooks, PDFs, and EPUBs — including "hybrid" documents where you've written on top of a PDF (the handwriting is composited onto the page).
• Typed text from reMarkable's own Connect conversion is used directly when present; handwriting is read using the OCR Provider you picked in Settings → Ingestion & OCR (see Settings & local models).
• Sync is incremental — unchanged pages aren't re-downloaded or read again.
• With Auto-sync on but Process automatically off, new pages are downloaded and rendered but reading/processing waits for you — useful if you want to pick what's worth processing.
• After changing OCR settings you can use Read again on a source (or Read page N again for a single page) from the Review screen instead of re-syncing.

Only the official reMarkable cloud sync is supported today (no rmfakecloud or USB/SSH transfer yet).

Notion

Bring in Notion pages and databases as sources.

Live API (recommended):

1. Create an internal integration at notion.so/profile/integrations.
2. Share the pages/databases you want with that integration.
3. Open Settings → Connections → Notion, paste the integration token, and sync.

Bulk export (zero-auth on-ramp): export your Notion content as Markdown & CSV and drag the ZIP/files onto Anthracite to import them as sources.

Notes on behavior:

• Allowlist only: after connecting, search and pick the pages/databases to sync — nothing is pulled until you do.
• Database rows each become their own source, capped at 200 rows per database by default (raise notion.maxDatabaseRows in config.json if you need more; the UI tells you when a database was truncated).
• Rich content converts to Markdown (headings, lists, code, tables, equations); file attachments are downloaded into the source where possible.
• Sync is incremental (unchanged pages are skipped), manual or Auto-sync.
• Notion sources are read-only in the Review screen — edits would be overwritten on the next sync. Fix things in Notion and re-sync instead.

See docs/NOTION-CONNECTOR-SPEC.md for connector details.

Readwise

Pull in your Readwise highlights (books, articles, tweets — whatever you highlight ends up in your wiki's pool).

1. Get your access token from readwise.io/access_token.
2. Open Settings → Connections → Readwise, paste it, Connect.
3. Sync now, or enable Auto-sync.

Each book/article becomes one source containing its highlights and your notes, with dates. Sync is incremental, and re-synced highlights are merged (no duplicates). Like Notion, Readwise sources are read-only in Review — the next sync would overwrite manual edits.

The token is stored in the macOS keychain, not in a config file.

After capture: processing

Whether a new source is processed automatically depends on Process automatically (Settings → Ingestion & OCR) and the per-connector policy:

• With Process automatically on, sources from folder watch, drag-and-drop, reMarkable, Readwise, voice, and Obsidian are processed as they arrive.
• Apple Notes, Notion, clips, and webhook posts stay pending by default — they tend to arrive in bulk, so you pick what's worth processing (you can add them to autoIngestConnectors in config.json to change that).

To process manually:

• Select a source in the sidebar and Process it, or
• Use ⌘K → Process All Pending Sources.

Then read the results — see Working with your knowledge.