canonical: https://jentic.com/apis/kaneme.com/kaneme

# Kaneme — API

The Kaneme API writes text in a person's own voice, learned from their real writing, and measures how faithfully a text matches that voice. It builds a voice from at least 100 words of human-written text, refines it through an interview, accepted or rejected signals, and added references, then generates or improves drafts in that voice for formats such as newsletter, linkedin_post, blog, or email. A verify operation returns a calibrated authorship probability for French and English, comparing the voice against AI or against another human, and abstains with a coded reason rather than guessing on unsupported or mixed languages. Projects, documents, public certificates, and a restorable trash round out the surface, and every paid call spends the same credits as the Kaneme app.

## For AI agents

Generate and improve text in a user's learned writing voice, score style automatisms, measure calibrated authorship probability in French or English, and organise the results as projects and documents with optional public certificates.

## Scope

Does not publish to social networks, check grammar, or detect AI text without a reference voice or samples. Use for writing in a learned personal voice and measuring authorship against it only.

## Capabilities

- Create a writing voice from at least 100 words of text with provenance set to human, then refine it through the voice interview
- Generate a draft, outline, section, challenge, bar-test, or workflow in the user's voice for formats such as newsletter, linkedin_post, or blog
- Improve an existing text so it reads in the user's voice
- Measure authorship as a calibrated probability with question q1 (voice against AI) or q2 (voice against another human), abstaining on unsupported languages
- Score a text for style automatisms at no credit cost, in any language the engine supports
- Teach the voice with accept, reject, or reject_reason signals such as trop_generique or trop_long
- Issue and publish a public certificate for a document, and verify any certificate by its token without an account

## Use cases

### Drafting in Your Voice Through Jentic

A writer's AI agent drafts posts and newsletters that sound like the writer rather than a generic model. Through Jentic the agent finds Kaneme's generate operation by intent, passes the prompt, format, and the writer's profileId, and saves the result as a document, while the developer decides which Kaneme operations the agent may call and the API key stays on their own machine.

Example prompt: List voices to find the active profileId, estimate the cost of operation 'generate', then call POST `/api/v1/generate` with type 'draft', format 'linkedin_post', and save true

### Authorship Checks on a Draft

Before publishing, an author wants to know whether a text still reads as theirs after heavy editing. Kaneme's verify operation returns a calibrated probability for the author's voice against AI with question q1, or against another human with q2, and returns probability null with a reason such as unsupported_language instead of guessing. An abstention is never charged.

Example prompt: Call POST `/api/v1/verify` with the draft text, question 'q1', and format 'blog', and report the probability or the unavailable reason

### Account-Free Trial Measurement

A visitor without a Kaneme account wants a quick authorship reading. The verdict operation takes exactly three samples of the person's writing of at least 100 words each plus the text to attribute, and the observatory operation flags passages worth rereading, both without an account or credits.

Example prompt: Call POST `/api/v1/verdict` with three samples of at least 100 words, the text, and question 'human', then call POST `/api/v1/observatory/signals` on the same text

### Certified Publication

A consultant wants readers to be able to check that an article carries their voice. The agent prepares a certificate for the document, the owner approves it, and the publish operation returns a page, JSON, and SVG badge. Anyone can later verify the certificate by token at no credit cost.

Example prompt: Call POST `/api/v1/certificates/prepare` with a documentId and displayName, and after owner approval call POST `/api/v1/certificates/publish` with the approvalId

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| POST | `/api/v1/voices` | Create a voice from real texts |
| POST | `/api/v1/generate` | Write in the user's voice |
| POST | `/api/v1/improve` | Improve an existing text in voice |
| POST | `/api/v1/verify` | Measure calibrated authorship probability |
| POST | `/api/v1/score` | Score style automatisms |
| GET | `/api/v1/estimate` | Estimate an action's credit cost |
| POST | `/api/v1/documents` | Create a document |
| GET | `/api/v1/certificate/{token}` | Verify a public certificate |

## Key resources

- **Voices** — Learned writing voices with references, interview, revision proposals, assets, beliefs, and per-channel subvoices.
- **Generation and measurement** — Generate and improve in voice, score style, verify and compare authorship.
- **Projects and documents** — Projects with RAG context and Markdown documents with search, update, trash, and lifecycle actions.
- **Certificates** — Prepare, publish, and publicly verify authorship certificates for documents.
- **Account and costs** — Plan tier, credits, and cost estimates before running an operation.

## AI readiness

This API is usable in Jentic One now. Its AI-readiness score against Jentic's framework shows where it stands today and where improvements would make it even easier for agents to use.

- **Score:** 63 / 100
- **Maturity:** AI-Aware
- **Dimensions:**
  - Foundational Compliance: 93 / 100
  - Developer Experience & Jentic Compatibility: 64 / 100
  - AI-Readiness & Agent Experience: 45 / 100
  - Agent Usability: 94 / 100
  - Security: 60 / 100
  - AI Discoverability: 53 / 100
- **View full report:** https://jentic.com/apis/kaneme.com/kaneme/scorecard
- **How the score is calculated:** https://docs.jentic.com/reference/api-readiness-framework/overview/
- **More about the dimensions:** https://docs.jentic.com/reference/api-readiness-framework/specification/#dimensional-model-overview

### Score it yourself

Every API in the directory is allowlisted, so you can re-score it with no key required.

- **Score your own API:** https://jentic.com/scorecard.md
- **Scoring CLI agent skill:** https://github.com/jentic/jentic-api-scorecard/blob/main/skills/jentic-api-scorecard/SKILL.md

```sh
npx @jentic/api-scorecard-cli score <openapi-url>
```

## Why Jentic

- **Setup:** Wiring Kaneme by hand means handling its kaneme_ bearer key and scopes, reading French-language operation docs, tracking credit costs and HTTP 402 stops, and passing Idempotency-Key headers on writes. Through Jentic you install once, import the Kaneme API from the API Directory, store the key once, and your agent calls it.
- **Permission scoping:** Kaneme puts the document id in the URL path for reads, updates, and trash (`/api/v1/documents/{id}`), so a rule can pin your agent to one document, while voice operations carry profileId in the body or query, so for those rules bound which operations it may call. You choose those operations, so sensitive ones like publishing certificates or applying voice revisions are not included unless you add them.
- **Credential handling:** Your Kaneme API key is stored once, encrypted, by your own Jentic One instance and injected at execution time. It never enters the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'write a newsletter in my voice' or 'check if this text is mine', and Jentic returns the matching Kaneme operation with its input schema so the agent calls the right endpoint without reading the French reference docs.

## Related APIs

- **Anthropic Messages API** — Claude generates text from prompts without a learned personal voice or authorship measurement.
- **LanguageTool** — LanguageTool checks grammar and spelling in French, English, and other languages.
- **Ghost** — Ghost publishes blog posts and newsletters written in voice with Kaneme.

## FAQ

### What authentication does the Kaneme API use?

Per its OpenAPI spec, the Kaneme API uses bearer authentication with an account API key created on the Connexions page, sent as Authorization: Bearer kaneme_ followed by the key, and older frq_ keys are still accepted. Key scopes are chosen when the key is created. Three operations need no credential: certificate verification by token, the account-free verdict, and the observatory signals read. Through Jentic the key is stored encrypted by your own Jentic One instance and injected at call time.

### Is there a Kaneme MCP server?

Yes - Kaneme offers an official MCP server at `/api/mcp.` You can also connect Kaneme directly through Jentic: your agent gets the full 48-endpoint surface from the spec without loading another server's tool definitions into its context, your key is injected at call time by your self-hosted instance instead of living in an MCP config, and your rules decide which operations the agent may call.

### Can I limit what my agent is allowed to do with the Kaneme API?

Yes. Write a rule that allows only the estimate, generate, and document create operations, so a drafting agent writes and saves posts but cannot publish certificates, decide voice revisions, or move documents to the trash. Every call it makes is logged, so you can review what it spent credits on.

### Which languages does Kaneme's authorship verification support?

Per the spec, the authorship verdict is calibrated on French and English, each with its own engine, and the English q2 comparison against another human is a strict beta. On other languages verification abstains and returns probability null with unavailable set to unsupported_language, while the style score still runs in every supported language and reports markerLanguage.

### How much does a Kaneme API call cost?

Each paid operation spends the same credits as the Kaneme app, and the API returns HTTP 402 when available credits run out. The style score costs nothing, abstentions are never charged, and GET `/api/v1/estimate` tells your agent what an action will cost before it runs.

### What are the rate limits for the Kaneme API?

The OpenAPI spec does not state numeric rate limits. Responses carry X-RateLimit-Limit, X-RateLimit-Remaining, and X-RateLimit-Window headers so your agent can pace itself, and the spec documents a 429 response when calls exceed the limit. See https://kaneme.com for plan details.

### How do I write a post in my voice with the Kaneme API through Jentic?

Search Jentic for an intent like 'write a post in my voice', import the Kaneme API from the API Directory, and store your API key. Your agent calls GET `/api/v1/voices` to pick the profileId, then POST `/api/v1/generate` with the prompt and a format such as newsletter, and can send POST `/api/v1/signal` with accept or reject so the voice learns. To run it on your own infrastructure, install Jentic One from its GitHub repo.