The Writer API
Your own code, acting as you
The Writer API is your scripts — and the LLMs you brief to write them — working directly against your book. It is the one surface where your own prose can flow in and out, because here it's your code acting as you, not an AI writing for you.
The deliberate difference
Why the API can do what MCP won't
Everywhere else, Calliope will not write your prose — the companion reads and checks, the MCP connector refuses to return a sentence at the protocol level. The Writer API is the deliberate exception, and the reason is simple: it isn't an AI acting for you. It's your code acting as you.
So this is the one surface where prose can move in and out — because you wrote the script, or briefed the model that wrote it, and you own what it does. That's a different thing from a ghostwriter, and we treat it as one.
How it works
A key, a base URL, and your book
Everything lives under https://app.writecalliope.ink/api/v1, and you authenticate with a personal Bearer key from your account. Point any script or HTTP client at it and you're working against your real manuscript.
Reading is free — pull chapters, synopses, your Map. Calls that spend AI draw on your credits, the same as in the app. And writes need a subscription, because writing back to your book is the surface we guard most carefully. The full endpoint list is in the API docs.
What writers build with it
“I've got 60,000 words spread across a pile of Markdown and Word files, and I'm not retyping any of it.”
What they do. He writes a small script that pushes each file in as a chapter over the Writer API, in order, in one pass.
The result. The one time you want prose written in — and it's allowed, because it's his own words being imported by his own code.
Build me a script that imports my existing manuscript into my Calliope book via the Writer API. I have a folder of chapter files (Markdown and .docx) that should become chapters in my book, in filename order. The Calliope Writer API: - Base URL: https://app.writecalliope.ink/api/v1 - Auth: send `Authorization: Bearer <key>`. Read the key from the CALLIOPE_API_KEY environment variable — never hardcode it. I create a key at https://writecalliope.ink/docs/api/setup - Before writing any code, fetch and read the machine-readable contract so you use the real endpoints: https://app.writecalliope.ink/api/v1/openapi.json and https://app.writecalliope.ink/api/v1/llms.txt - Tiers: reading is free; AI calls spend credits; writes (including chapter prose) need a subscription — see https://writecalliope.ink/docs/api/prose-write Do this: 1. Read the OpenAPI contract first, then plan against the real endpoints. 2. Read each source file in order, converting .docx to clean text with paragraph breaks preserved. 3. Create one chapter per file and write its prose in. 4. Support a --dry-run flag that lists what it would create without writing anything; make that the default. If my book already has chapters, stop and ask before adding more. 5. Print a summary: chapters created and words imported.
“I want a bespoke export nobody built for me — each chapter as its own file, with the synopsis at the top.”
What they do. She briefs Claude to write a script using her Writer API key that saves every chapter to a file with its synopsis as frontmatter.
The result. Calliope becomes programmable by anyone who can describe the job, not just people who can write the code.
Build me a script that exports my Calliope book to one Markdown file per chapter, each with the chapter's synopsis as YAML frontmatter. The Calliope Writer API: - Base URL: https://app.writecalliope.ink/api/v1 - Auth: send `Authorization: Bearer <key>`. Read the key from the CALLIOPE_API_KEY environment variable — never hardcode it. I create a key at https://writecalliope.ink/docs/api/setup - Before writing any code, fetch and read the machine-readable contract so you use the real endpoints: https://app.writecalliope.ink/api/v1/openapi.json and https://app.writecalliope.ink/api/v1/llms.txt - Tiers: reading is free; AI calls spend credits; writes (including chapter prose) need a subscription — see https://writecalliope.ink/docs/api/prose-write (This one is read-only — it never writes back to Calliope, so no subscription needed.) Do this: 1. Read the OpenAPI contract, then list my chapters in reading order. 2. For each chapter, fetch its prose and its synopsis. 3. Write ./export/<NN>-<slug>.md with frontmatter (title, synopsis) followed by the chapter text. 4. Print what it wrote.
“Every scene break should be the same three asterisks, and every spelling should be British. Across the whole book.”
What they do. He runs a deterministic script over the API — a plain find-and-replace across chapters, reversible, no model involved.
The result. The mechanical work no AI should touch creatively, done exactly and safely, with prose flowing through his code.
Build me a deterministic script (no AI, no model calls) that applies my house style across my whole Calliope book in place, over the Writer API. Rules to apply to every chapter's prose: - normalise every scene break to exactly "* * *" - convert US spellings to British English (use a maintained word list; I'll review the mapping) The Calliope Writer API: - Base URL: https://app.writecalliope.ink/api/v1 - Auth: send `Authorization: Bearer <key>`. Read the key from the CALLIOPE_API_KEY environment variable — never hardcode it. I create a key at https://writecalliope.ink/docs/api/setup - Before writing any code, fetch and read the machine-readable contract so you use the real endpoints: https://app.writecalliope.ink/api/v1/openapi.json and https://app.writecalliope.ink/api/v1/llms.txt - Tiers: reading is free; AI calls spend credits; writes (including chapter prose) need a subscription — see https://writecalliope.ink/docs/api/prose-write Do this: 1. Read the OpenAPI contract and the prose-write doc first. 2. Fetch each chapter, apply the rules as pure find-and-replace, and write back ONLY the chapters that changed. 3. Default to a dry run that prints a per-chapter diff; only write when I pass --apply. 4. Never call a language model — this must be fully deterministic and reversible.
“I want this backed up somewhere I control, and my latest chapter live on my site.”
What they do. A script snapshots the whole book to her own git and pushes the newest chapter to her static site whenever she runs it.
The result. Calliope as the source of truth, and provable proof she owns her words — exported by her, into her own hands.
Build me a script that (a) snapshots my entire Calliope book into a local git repo and (b) publishes my most recently updated chapter to my static site. The Calliope Writer API: - Base URL: https://app.writecalliope.ink/api/v1 - Auth: send `Authorization: Bearer <key>`. Read the key from the CALLIOPE_API_KEY environment variable — never hardcode it. I create a key at https://writecalliope.ink/docs/api/setup - Before writing any code, fetch and read the machine-readable contract so you use the real endpoints: https://app.writecalliope.ink/api/v1/openapi.json and https://app.writecalliope.ink/api/v1/llms.txt - Tiers: reading is free; AI calls spend credits; writes (including chapter prose) need a subscription — see https://writecalliope.ink/docs/api/prose-write (Read-only against Calliope — no subscription needed.) Do this: 1. Read the OpenAPI contract, then pull the whole book: every chapter in order, plus the outline/Map if available. 2. Write it as Markdown into ./calliope-backup, then git add and commit with a timestamped message (init the repo if it doesn't exist). 3. Find the most recently updated chapter and copy it into my site's content folder — ask me for that path the first time and remember it. 4. Print a summary and make every step safe to re-run.
Your book, programmable
Point your own code at your book
Get a Bearer key, read for free, and build the tool only you needed. When your code writes prose in or out, it's you writing — and that's exactly the point.
Start writing — free