Let an AI agent edit your App Store screenshots

Screenshot Studio speaks MCP. Connect Claude Code — or any MCP client — and an agent can read the project you have open, translate every caption, move a headline, and look at the rendered slide to check its own work. The app stays in front of you the whole time: the canvas repaints as the agent edits, and you keep the slide you were on.

What you need

The Mac app, running — download it here if you haven't.
Node 20 or newer (for npx).
An MCP client: Claude Code, Claude Desktop, or anything that speaks the protocol.

Connect

In Claude Code, one command:

claude mcp add screenshot-studio -- npx -y screenshot-studio-mcp

In a client with a JSON config (Claude Desktop and most others):

{
  "mcpServers": {
    "screenshot-studio": {
      "command": "npx",
      "args": ["-y", "screenshot-studio-mcp"]
    }
  }
}

Both are also one click away inside the app: the MCP chip in the header opens a card with Copy config and Copy Claude Code command.

Then ask your agent to call live_status. It answers with what the app has open — step, project name, slide count, locales. If it says the app is not running, open the app (or check the switch described below) and ask again.

What the agent can do

Tool	What it does
`live_status`	Is the app running, and what does it have open?
`live_focus`	Move you to a step or slide. Changes no data.
`live_new_project`	Start a blank project and jump to the editor.
`live_inspect`	Read the open project as compact JSON — per-slide template, device, texts and badges with their field addresses, external images, structural issues.
`live_list_untranslated`	The localize worklist: every string still missing a locale, with its source text and address.
`live_patch`	Apply surgical edits — text, position, style, background, device frame, external images.
`live_view`	Render one slide at export resolution and return it as an image, so the agent can see the result.
`live_save`	Write the open project back to its own `.studio.zip` — the same thing ⌘S does.
`live_open`	Open a `.studio.zip` from disk as the live document.
`get_design_reference`	Theme ids, fonts, layouts, ornaments, locales, device models and export sizes, per-slide limits.
`get_patch_spec` / `get_import_spec`	The op vocabulary and the manifest authoring spec.

Four things worth asking for

1. Translate the whole set

“Translate every missing caption into Japanese and German.” The agent calls live_list_untranslated, writes the translations back with live_patch, and the Localize table fills in as it goes. A language your project hasn't selected yet is added automatically. No CSV export, no re-import.

2. Fix what it can see

“Slide 3's headline is colliding with the device — fix it.” live_view renders the slide at the real export size, so the agent judges the layout that actually ships, patches, and looks again.

3. Save when the batch is done

On the Mac a project is a file. An agent's patch dirties it exactly like your own edit and nothing autosaves, so “translate everything and save” ends with one live_save — the title bar's dot clears and the file on disk matches what you see. A project that has never been saved is refused: you pick the location once, in the app.

4. Draft from scratch

“Make me a 5-slide iPhone project on the porcelain theme with these captions.” live_new_project then a batch of live_patch ops. You still add the screenshots — the agent has no access to your files.

The switch

The header card has an on/off switch, and off means off: the socket is unlinked and nothing is listening. The choice persists across launches, so a bridge you turned off stays off from the very first second of the next launch — not "until the window finishes loading". Turn it back on in the same place.

How it connects — and why it isn't a port

The app listens on a unix domain socket in your own Library folder, mode 0600, not on 127.0.0.1:<port>. A web page in a browser cannot open a unix socket, which removes the whole class of attacks where a page you happen to be visiting quietly drives a desktop app that writes files. The socket path is in the card if you ever need it for debugging, but nothing you register with it needs to know the path.

Nothing leaves your Mac: the agent talks to the app, the app edits your project locally.

The file-based half

Driving the open app is one way to work; the other is files. From a checkout of the repository, the same MCP server also exposes the pipeline tools — render an authored folder to final PNGs, patch a saved .studio.zip losslessly, run the layout autofix loop — which is what you want in CI or for a batch of releases. Same op vocabulary either way.

Download App Store Screenshot Studio for macOS — free, open source, signed and notarized. Your screenshots never leave your Mac. →

FAQ

Does any of this upload my screenshots?
No. The MCP server runs on your machine and talks to the app through a local socket. The app has no backend (see the privacy policy).

Do I need an API key?
No. The intelligence is your own MCP client; the app provides no model and holds no keys.

Windows or Linux?
The desktop app is macOS-only today, so the live tools are too.

Can the agent see my other files?
No. The bridge speaks a fixed vocabulary about the open project — there is no "read this file" call, and ops that would pull in an image from disk are rejected on the live path.