KDP Studio MCP
Integrates with Amazon KDP (Kindle Direct Publishing) to read paperback drafts and make a guarded draft change. Provides tools for listing KDP tabs, inspecting draft title/ISBN/page count/preview certification state, and setting MATTE or GLOSSY cover finish on an existing uncertified draft with read-back verification.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@KDP Studio MCPChange my KDP draft's cover finish from matte to glossy."
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
KDP Studio MCP
Independent, experimental MCP for reading KDP paperback drafts and making one guarded draft change through a user-authorized Chrome session. It is not affiliated with Amazon or KDP.
It deliberately has a small surface: it cannot publish a book, buy a proof, upload files, delete a draft, assign an ISBN, or expose cookies and tokens.
How it works
Your MCP client starts this local Python server. The server starts Chrome DevTools MCP, which attaches to a Chrome browser you have already launched with remote debugging and where you are already signed in to KDP. Requests run inside that browser session. Credentials and CSRF tokens stay in the browser and are never returned by this MCP or written to disk.
MCP client → KDP Studio MCP → Chrome DevTools MCP → signed-in Chrome → KDPKDP does not provide a public API for this workflow. This project uses narrowly observed KDP web requests and may require updates when KDP changes its site.
Related MCP server: chrome-bridge
Setup
Clone the public repository, then run setup from its root. Use an isolated Python virtual environment.
Requires Python 3.11+, Node.js/npm (for npx), and a current Chrome version.
Launch Chrome with remote debugging enabled. On Windows, close every Chrome process first, then start:
& "$env:ProgramFiles\Google\Chrome\Application\chrome.exe" --remote-debugging-port=9222On macOS/Linux, start Chrome with
--remote-debugging-port=9222.Sign in to KDP in that Chrome profile and open the draft's Content page.
Clone and install the server:
git clone https://github.com/fatoh2/kdp-mcp.git
cd kdp-mcp
python -m venv .venv
# Windows: .venv\Scripts\activate
# macOS/Linux: source .venv/bin/activate
pip install -e ".[dev]"
python -m kdp_mcp.serverThe MCP uses the official Python SDK 1.30.0 and Chrome DevTools MCP 1.9.0.
No Bookforge imports or services are required. Reads work by default; set
KDP_ENABLE_WRITES=1 in the server environment to expose executable draft writes.
Add it to your MCP client's configuration (replace the Python path with your virtual environment):
{"mcpServers":{"kdp":{"command":"/absolute/path/to/venv/bin/python","args":["-m","kdp_mcp.server"],"env":{"KDP_ENABLE_WRITES":"1"}}}}On Windows use the virtual environment's Scripts/python.exe. Omit the environment
flag for read-only operation. Reload the MCP client after changing configuration.
Using it safely
Call kdp_tabs first and use the returned page ID. Then call
kdp_draft_status with that page ID and the KDP draft ID to inspect its state.
The read-only tools are always available.
kdp_set_cover_finish is only exposed when KDP_ENABLE_WRITES=1. It accepts a
page ID, draft ID, target MATTE or GLOSSY finish, and the finish you expect
to be set now. The MCP rejects live/certified drafts and mismatched tabs, checks
the current finish, saves once, then reads back the result. Treat an unknown
outcome as potentially saved: inspect the draft manually before doing anything
else.
Tool | Behavior |
| Returns only KDP tabs, stripping URL queries |
| Reads draft title, ISBN, page count and preview/certification state |
| Saves MATTE/GLOSSY on an existing uncertified DRAFT and verifies it |
Write calls require a matching content tab, draft ID, and expected current finish.
They read the latest settings, retain unrelated print/ISBN fields, acquire a fresh
CSRF token in Chrome, submit once, and read back. No token or cookie is exported.
Timeouts after submission produce unknown: inspect before retrying. The expected
value check is optimistic, not a server-side atomic lock; do not edit the same book
from another tab while saving. Writes are serialized within this MCP instance.
No publication, deletion, proof purchase, ISBN assignment, or general-purpose HTTP tool is exposed. Uploads and metadata/pricing writes are not yet implemented. An available preview is not a passing preview. Internal endpoints can change.
See network evidence, contributing, and tasks.
Tests
pytest -qTests execute generated JavaScript in Node with mocked KDP responses, checking write guards, payload preservation, read-back and uncertain-submission handling.
Validated September 14, 2026: unit tests cover read/write responses, input validation, payload preservation, unsafe states, and uncertain writes; CI runs them on every pull request. A live save of an existing uncertified draft preserving its MATTE finish, verified through a fresh read. An actual MATTE-to-GLOSSY transition remains unverified against live KDP.
Available Tools
3 toolskdp_draft_statusB
Read an existing paperback draft. Does not certify, save, upload or publish.
| Name | Required | Description | Default |
|---|---|---|---|
| page_id | Yes | ||
| draft_id | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full behavioral burden; it does usefully disclose the absence of side effects (no certify/save/upload/publish). It says nothing about permissions, scoping of the draft to a page, or read-only guarantees beyond that single negative clause.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two short sentences, zero padding, with the positive purpose front-loaded and the negative boundary second. Every clause earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
An output schema exists, so return values need not be described. But for a two-parameter tool with 0% schema coverage and no annotations, the description omits parameter meaning entirely, leaving a notable gap even for a simple read operation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0% and the description adds no meaning for either required parameter. An agent gets no indication of what page_id vs draft_id represent, how they relate, or what format draft_id takes.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb (read) and resource (existing paperback draft), which is clear enough to distinguish it from the sibling mutators kdp_set_cover_finish and kdp_tabs. However, the name says 'status' while the description says 'Read an existing paperback draft', leaving slight ambiguity about whether it returns draft state or draft content.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
'Does not certify, save, upload or publish' establishes that this is the non-mutating option, implying it is the read path among siblings. But it never states when to call it, what it presupposes (an existing draft_id), or names an alternative to prefer in other cases.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
kdp_set_cover_finishB
Save MATTE/GLOSSY on an uncertified existing draft, then verify. User-authorized writes only.
| Name | Required | Description | Default |
|---|---|---|---|
| finish | Yes | ||
| page_id | Yes | ||
| draft_id | Yes | ||
| expected_finish | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must carry the behavioral load. It usefully discloses that this is a write requiring user authorization and that it verifies afterward, but it omits what happens on failure, whether a mismatched expected_finish aborts the write, or whether the operation is idempotent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two short sentences, front-loaded with the operation and its scope; nothing is padded. The telegraphic style costs a little clarity but wastes no space.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
An output schema exists, so return values need not be described, and the description covers goal, precondition, and auth. However, for a four-parameter mutation with 0% schema coverage and no annotations, leaving the parameter set and failure behavior unexplained is a meaningful gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0% across four required parameters, so the description is the only source of meaning. It hints that 'finish' takes MATTE or GLOSSY, but page_id, draft_id, and especially expected_finish are left completely undefined.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb (Save) and resource (MATTE/GLOSSY cover finish) scoped to an existing draft, and adds a verify step. It is clearly distinct from kdp_tabs and kdp_draft_status, though it never explicitly names them.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives a precondition ('on an uncertified existing draft') and an authorization rule ('User-authorized writes only'), which is real usage guidance. It stops short of saying when to prefer this over alternatives or what to do when the precondition fails.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
kdp_tabsB
List only KDP tabs. Chrome may ask the owner to allow the connection.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full behavioral burden. It does disclose one real trait — that Chrome may prompt the owner to allow the connection — which is genuinely useful operational context. It says nothing about read-only status, what happens if the connection is denied, or how to retry.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two short sentences, purpose front-loaded, caveat second. Every clause carries information and there is no filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
An output schema exists, so return values need not be explained, and there are no parameters to document. Still, for a tool whose name is opaque ('KDP tabs'), the description leaves the domain and the consequence of the Chrome permission prompt unexplained, which an agent may need to call it confidently.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool takes zero parameters, so there is nothing for the description to disambiguate; the baseline for a parameterless tool is 4. No misleading parameter guidance is present.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb (List) and resource (KDP tabs) with a scope qualifier ('only KDP tabs'), which distinguishes it from a generic tab-listing tool. However, 'KDP tabs' is never defined (browser tabs vs. KDP project views), so the agent must infer the domain from the sibling names.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no statement of when to use this versus kdp_draft_status or kdp_set_cover_finish, nor any prerequisite or exclusion. The only usage signal is the implicit fact that it is a listing operation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
3 tool updates
v0.2.0- First observed
kdp_draft_status - First observed
kdp_set_cover_finish - First observed
kdp_tabs
TDQS
Scored across 3 tools
kdp_tabs, kdp_draft_status, and kdp_set_cover_finish target distinct actions (listing tabs, reading draft status, setting cover finish), so an agent can easily differentiate them. The only minor ambiguity is the vague term 'tabs', but the description clarifies it refers to KDP browser tabs.
All tools share a 'kdp_' prefix and use snake_case, but the suffix pattern is inconsistent: tabs (noun), draft_status (noun_noun), and set_cover_finish (verb_noun_noun). This mix of noun-only and verb-based names makes the naming convention less predictable.
Three tools are far too few for a server named 'KDP Studio' that presumably should manage many aspects of paperback publishing. The set only covers a tiny slice of functionality, leaving most operations unaddressed.
The surface is severely incomplete: there is no way to create a draft, update metadata, upload a manuscript, certify, or publish. Only a read and one specialized write are provided, which will cause agent failures for common KDP workflows.
Maintenance
Related MCP Connectors
Browser MCP for logged-in tasks. Uses your Chrome — credentials stay local. Zero-token replay.
Hosted real Google Chrome MCP with per-user persistent state. Navigate, click, type, screenshot.
Run multi-step tasks in a real Chrome browser: persistent environments, live view, human takeover.
Real Chrome for agents: start a browser, read pages as numbered markdown, click, type, hand off.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceEnables reading and writing Canvas LMS course content using browser session cookies, without needing an API key.MIT
- FlicenseNot gradedqualityCmaintenanceProvides a direct bridge between Claude and an authenticated Chrome session, enabling fetch requests with session cookies and JavaScript execution within live web pages.-
- AlicenseNot gradedqualityBmaintenanceEnables MCP-compatible agents to securely control the user's already authenticated Chrome browser via explicit tab authorization and DOM-based actions.1Apache 2.0
- AlicenseBqualityCmaintenanceEnables AI to control your existing logged-in Chrome session via MCP, supporting social media drafting and explicit user-confirmed publishing.8MIT