Parable docs · Integrate

Share to Parable

Add a Share to Parable button (or a Create note in Parable action) to your app, so a user can hand a snippet of content — a title, a body, a few tags — straight into their own end-to-end-encrypted, post-quantum-signed Parable notebook in one click. Your app never sees Parable's keys; Parable never sees your user's plaintext until they tap Save on their own device.

PATENT PENDING · Ma'atara Protocol

1. The button

The simplest integration is a single anchor tag. Drop it anywhere users would expect a "send to my notes" action — next to a bookmark icon, inside a share sheet, in an editor toolbar. Live preview:

Share to Parable Tap to try with a sample payload

HTML + minimal CSS

<!-- Share to Parable / Create note in Parable -->
<a class="prabl-button"
   href="https://prabl.ai/share?title=My%20note%20title&body=Hello%20from%20my%20app&tags=demo,integration"
   target="_blank" rel="noopener">
  <span class="prabl-button__mark" aria-hidden="true">P</span>
  <span class="prabl-button__label">Share to Parable</span>
</a>

<style>
  .prabl-button {
    display: inline-flex; align-items: center; gap: 8px;
    padding: 8px 14px; border-radius: 9999px;
    background: #0b0b0c; color: #f3e9c7;
    font: 600 14px/1 system-ui, sans-serif;
    text-decoration: none; border: 1px solid #d4b85a;
    transition: background .15s ease, transform .15s ease;
  }
  .prabl-button:hover { background: #15151a; transform: translateY(-1px); }
  .prabl-button__mark {
    display: inline-flex; align-items: center; justify-content: center;
    width: 20px; height: 20px; border-radius: 9999px;
    background: #d4b85a; color: #0b0b0c; font-weight: 800;
  }
</style>

2. Compose URL contract

The stable, public integrator URL is:

https://prabl.ai/share?title=<title>&body=<body>&tags=<t1,t2,…>

/share is a thin redirector — it normalises the payload and forwards to /notes?compose=1…, where the signed-in user's editor opens with the supplied fields pre-filled. Both URLs accept the same query parameters; integrators should prefer /share for forward compatibility.

Parameter	Type	Limit	Notes
title	string	200 chars	URL-encoded. Becomes the note's title field.
body	string (multiline)	20 000 chars	URL-encoded. Newlines as `%0A`. Markdown is preserved verbatim.
tags	comma-separated	16 × 64 chars	Trimmed; empty entries dropped.
compose	flag	—	Optional on `/share`; required on `/notes`.

The user is always shown the pre-filled draft before anything is signed or written to their chain. Parable never silently commits content arriving from another origin.

3. Data shape

Logically the integrator hands Parable a ComposeRequest with three optional fields:

type ComposeRequest = {
  title?: string;        // ≤ 200 chars,   plain text
  body?:  string;        // ≤ 20 000 chars, plain text / markdown
  tags?:  string[];      // ≤ 16 entries,  each ≤ 64 chars
};

All fields are optional. Sending an empty request still opens a blank new-note editor — useful for a generic "Create note in Parable" action. Future fields (e.g. attachments, source) will be additive; integrators can ignore parameters they do not recognise.

4. JS helper

If you'd rather wire it from JavaScript than emit a static link:

shareToParable() — vanilla JS

function shareToParable({ title, body, tags } = {}) {
  const url = new URL('https://prabl.ai/share');
  if (title) url.searchParams.set('title', title);
  if (body)  url.searchParams.set('body',  body);
  if (tags && tags.length) url.searchParams.set('tags', tags.join(','));
  // open in a new tab — Parable handles sign-in, decryption and the
  // pre-populated editor on its side.
  window.open(url.toString(), '_blank', 'noopener');
}

// Example
shareToParable({
  title: 'Field notes — 2026-05-24',
  body:  'Observation: …',
  tags:  ['field', 'draft'],
});

CLI / shell:

curl / xdg-open

# Open the compose surface in a browser
xdg-open "https://prabl.ai/share?title=Quick+capture&body=From+CLI&tags=ops,cli"

5. UX & auth behaviour

Signed in already? Parable opens the /notes editor in a new tab with title, body and tags pre-populated. The user reviews and taps Save.
Not signed in? Parable bounces to the welcome flow, stashes the compose payload in the user's sessionStorage, and re-applies it automatically the moment they reach /notes. The payload never leaves their browser.
Locked identity? The inline unlock prompt (passkey or passphrase) appears first; the compose payload is held until the editor mounts.
No silent commits. The user always sees the prefilled draft and explicitly chooses to save. Closing the tab discards the draft client-side.

6. Privacy contract

The compose URL is a hand-off, not an API call. Concretely:

The query string is processed entirely in the user's browser. The Parable Cloudflare edge sees only the HTML asset request; it does not parse, log or persist title, body or tags.
On save, the body and attachments are encrypted with AES-256-GCM under a per-note key sealed to the user's ML-KEM / Kyber768 identity, then signed with ML-DSA / Dilithium2 and committed to their Veritas chain. The integrator origin is irrelevant past the hand-off.
Do not send secrets, access tokens or third-party PII in the URL. Browser history, screen recorders and referrer headers can see anything in a URL bar. Use the compose surface for user-authored content only.
For headless, signed integrations (server-to-server provenance, automated note creation, etc.) use the signed-envelope endpoints documented under Developer endpoints instead.

7. Brand & placement

The "Share to Parable" wordmark, the gold dot, and the prabl.ai domain are the only required brand surfaces. The button above is a reference implementation — feel free to restyle it to fit your product, with two constraints:

Keep the word Parable in the label (e.g. "Share to Parable", "Save in Parable", "Open in Parable").
Link to prabl.ai or a subpath of it; do not deep-link past /share or /notes.

That's the whole contract. If you ship something we should know about, say hi at ma-atara.io.