How to Generate App Store Screenshots From Claude Code or Cursor

To generate App Store screenshots from Claude Code or Cursor, connect a screenshot MCP server to the agent, then ask for store screenshots in plain English. With Launch Shots, that's one line in Claude Code: claude mcp add --transport http launchshots https://www.launchshots.com/api/mcp. The agent reads your codebase, gathers three to eight of your key screens, uploads them, and about two minutes later hands you a link to three finished, editable design directions.

We announced the server in Introducing the LaunchShots MCP Server. This is the practical companion: setup for every client, what happens at each step, prompts that work, and what tends to separate a good set from a generic one.

What is an MCP server, and why use one for screenshots?

The Model Context Protocol (MCP) is an open-source standard for connecting AI applications to external systems. An MCP server exposes tools an agent can call, and any client that speaks the protocol can use them. That's why the same Launch Shots endpoint works in a terminal agent, an IDE and a chat app.

Screenshots are a good fit for this because the hard part isn't the pixels. It's knowing what the app does, which screens matter and how to describe them, and a coding agent sitting in your repository already has most of that context. It can read the README, find the screens in code and, if it can run a simulator, capture them.

How to add the Launch Shots MCP server to your agent

These are the free-tier snippets, exactly as they appear on the MCP server docs page. If you create an API key, the same snippet gains an Authorization header; account settings gives you the finished version when you create one.

Claude Code

claude mcp add --transport http launchshots https://www.launchshots.com/api/mcp

With an API key:

claude mcp add --transport http launchshots https://www.launchshots.com/api/mcp \
  --header "Authorization: Bearer ls_key_…"

Then type /mcp__launchshots__store_screenshots, or just ask for store screenshots.

Cursor

In ~/.cursor/mcp.json:

{
  "mcpServers": {
    "launchshots": {
      "url": "https://www.launchshots.com/api/mcp"
    }
  }
}

VS Code

In .vscode/mcp.json:

{
  "servers": {
    "launchshots": {
      "type": "http",
      "url": "https://www.launchshots.com/api/mcp"
    }
  }
}

If you add a key here, keep the file out of version control or move the key into an input variable. This file lives in your repository.

Windsurf, Codex CLI and Gemini CLI

Windsurf, in ~/.codeium/windsurf/mcp_config.json:

{
  "mcpServers": {
    "launchshots": {
      "serverUrl": "https://www.launchshots.com/api/mcp"
    }
  }
}

Codex CLI, in ~/.codex/config.toml:

[mcp_servers.launchshots]
url = "https://www.launchshots.com/api/mcp"

Gemini CLI, in ~/.gemini/settings.json:

{
  "mcpServers": {
    "launchshots": {
      "httpUrl": "https://www.launchshots.com/api/mcp"
    }
  }
}

Note that each client names the URL key differently (url, serverUrl, httpUrl), so copy the snippet for your client rather than adapting another one. Any other client that speaks Streamable HTTP works with the bare URL. In Claude.ai and Claude Desktop it's Settings, then Connectors, then Add custom connector; custom headers aren't supported there yet, so it runs on the free tier.

What the agent does when you ask for screenshots

The server tells the agent how to work, so you don't have to. A typical run goes like this:

1. It learns the app. It reads the README, any store copy in the repository (fastlane/metadata or similar) and the main screens in code, and notes the app's name, what it does, who it's for and what makes it different.
2. It gathers 3–8 screenshots. It looks for recent ones first (fastlane/screenshots, screenshots/, docs/, assets/). Otherwise it captures them with xcrun simctl io booted screenshot or adb exec-out screencap -p, navigating itself if it can, or asking you to open screens if it can't. It shows you its list before uploading.
3. It uploads and starts the design. prepare_screenshot_upload returns one upload URL per screenshot with ready-to-run curl commands; generate_screenshot_set starts the design and immediately returns the review link.
4. It waits and reports back. get_screenshot_set waits for the result, then the agent gives you the link and the headline written for each screen.

Agents that can't run shell commands can send small screenshots inline instead of uploading them. There are two more tools, get_account (which account you're on and what's left) and list_projects (recent projects, with a key).

What you get back

The review link opens a page with your set in three art directions. All three share one set of headlines, written per screen from what's actually on it and from the description the agent sent. You pick the direction you like and it opens in the Launch Shots editor as a normal project.

Nothing is locked. Every headline, colour and device frame is editable, and the project exports at every size App Store Connect and Google Play Console require, or publishes straight to them. If a headline is close but not quite right, our screenshot copywriting guide is a useful check before you ship it.

Guest vs API key: limits and pricing

A run that fails, times out or is refused is refunded automatically, and the agent can retry the same set. The pricing page has the current credit and plan prices. Treat the review link like a private document link: anyone who has it can see the set.

Example prompts that work

You can be as brief as you like, but a little direction goes a long way.

• "Make App Store screenshots for this app."
• "Create Play Store screenshots in German — lead with the offline mode."
• "Take screenshots of the onboarding, dashboard and settings screens in the simulator, then turn them into a store set."
• "Generate the iPhone and iPad sets, dark and premium."
• "Use the screenshots in fastlane/screenshots/en-US. The audience is freelance designers; the differentiator is invoicing in their client's currency."
• "Make a set for the App Store in Japanese, playful, using our brand orange #FF6B00."

Those map onto inputs the tool accepts: the platform, the store language (en-US, de-DE, ja, pt-BR and so on), an optional style note, and whether to include the tablet set. In Claude Code, the /mcp__launchshots__store_screenshots prompt also takes a platform and a focus.

Tips for better results

Give it real screens with real-looking data

This matters more than anything else. Headlines are written from what's on screen, so an empty state produces a headline about nothing. Avoid login walls, permission dialogs, debug banners and lorem ipsum. If the agent is capturing from a simulator, have it set a clean status bar and load demo data first; our guide to clean simulator and emulator screenshots has the commands, and your agent can run them.

Tell it which screens you care about

Agents pick sensibly, but they don't know which feature you're betting the release on. Name it. And think about order: the first screenshot does most of the work, so our post on what to put on your first App Store screenshot is worth a read before you decide what leads.

Make the description specific

The agent writes the app description from your README. If your README is a build guide, point it at better copy: your store listing, landing page or pitch. "A habit tracker" gives generic headlines; "a habit tracker for people with ADHD that never punishes a missed day" gives headlines with an angle.

Review before you publish

Read every headline as a stranger would. Check claims are true, prices and numbers are current, and nothing shown would trip App Review; our breakdown of why Apple rejects App Store screenshots covers the usual problems.

Use it for localization too

Ask for the same set in another store language, or translate the project once it's in the editor. If the app UI is localized, have the agent capture the localized screens as well, since headlines in one language over a UI in another look unfinished.

If something doesn't work

• The agent doesn't see the tools. Most clients load MCP servers at startup, so restart the session after editing the config. In Claude Code, /mcp lists connected servers and their status.
• It can't capture screenshots. The agent needs a booted simulator or a running emulator, plus permission to run shell commands. If it can't navigate your app, it should tell you which screens to open; you can also point it at a folder of existing captures instead.
• Uploads fail. Upload URLs are valid for two hours, so a long pause between preparing and uploading can expire them. Ask the agent to start again with prepare_screenshot_upload. Agents without a shell can send screenshots inline, each under about 1 MB.
• An API key is rejected. A key that's present but invalid returns an error rather than falling back to the free tier. Check for a stray space or an old, revoked key in the config.
• The headlines are generic. In our experience the input is usually the cause. Give the agent better screens and a sharper description, and run it again.

The short version

• Add the server once: one line in Claude Code, a few lines of JSON in Cursor, VS Code, Windsurf or Gemini CLI, TOML in Codex.
• Ask for store screenshots, or run /mcp__launchshots__store_screenshots in Claude Code.
• Make sure the agent sends 3–8 key screens with realistic content, and tell it which feature should lead.
• Open the review link, pick one of three directions, and finish it in the editor.
• Start without a key; add an API key when you want sets in your account, tablet sets and longer retention.

If you'd rather do it by hand, the App Store screenshot generator does the same job in the browser, and our step-by-step guide covers the process end to end.