App Store Connect MCP server

Ship an App Store release without leaving your agent.

41 tools that drive App Store Connect from Claude Code, Cursor, or any MCP client: edit metadata, upload screenshots, attach builds, run TestFlight, submit, release. The steps Apple's API cannot do are flagged before you hit them, not after you are half done.

Start free, no card
npx @pofky/asc-mcp init

Install, then ask your agent to run asc_start_trial. Every tool unlocks for 7 days, no card and nothing to cancel. Your .p8 key never leaves your machine. How setup works

asc_setup_check
> is my App Store Connect setup working?

App Store Connect MCP, setup check
========================================

[OK]   API key file (.p8): Found ~/.appstoreconnect/private_keys/AuthKey_2X8••••••.p8
[OK]   Key ID: 2X8••••••
[OK]   Issuer ID: 69a1c7f4-••••-••••-••••-••••••••••••
[OK]   Live connection: Authenticated against App Store Connect and listed apps.
[WARN] License: Free tier: read + intelligence tools only. Not a problem; the free tools work.
        Fix: Run `asc_start_trial` for 7 days of everything, no card. It unlocks
        write/control in this session, no restart.

Ready. Try `list_apps`, then `asc_guide` (topic:overview) to see every flow.
asc_start_trial
> push the new description and screenshots to 1.2

Editing metadata requires Pro.

Free for 7 days, no card: call the asc_start_trial tool with the user's email.
It unlocks all 41 tools in this session immediately, no restart.

> yes, start it, my email is you@example.com

Pro trial started. 7 day(s), no card, nothing to cancel.

License key: ASC-••••••-••••••-••••••-••••••
Saved to ~/.claude.json (backup alongside), so it survives a restart.

All 41 tools are unlocked in this session right now. Retry what you were doing.
When the trial ends, Pro is $9/month.

That is the whole signup. No account on this site, no card, no restart, and the agent does it in the conversation you are already in.

start my asc-mcp trial, my email is you@example.com
The pipeline

A release is a state machine. Here is who drives each state.

App Store Connect moves a version through fixed states. Most of those transitions have an API. A few do not, and no MCP server can invent one. Amber lists the tool calls your agent makes. Red marks the stages only the website can do, and asc_guide hands you those steps with the deep link.

  1. Manual, one time

    The app record exists

    POST /v1/apps is forbidden for API keys, so the record is created once on the website.

    ASC website > Apps > +

  2. Prepare for submission

    Metadata, price, availability, age rating

    Character limits are validated before the write, so Apple does not bounce it. Price equalizes to about 175 territories.

    update_version_metadata · set_app_metadata · set_app_price · set_app_availability · set_age_rating

  3. Build processing

    Compile, sign, upload, attach

    Manual-signing profiles are created via the API, then the archive is built and uploaded locally with Xcode's toolchain.

    setup_app_store_signing · build_and_archive · upload_binary · wait_for_build · attach_build

  4. Assets and products

    Screenshots, subscriptions, in-app purchases

    Screenshots upload per display type. Subscriptions get a group, localization, territory availability, a USA base price fanned out to every territory, and a free trial.

    upload_screenshots · create_subscription · create_iap · set_iap_review_screenshot

  5. Manual, website only

    Privacy nutrition label and EU trader status

    Neither is in the public API. Both tools return the exact checklist plus the deep link instead of pretending to write them.

    set_privacy_nutrition · set_eu_trader_status

  6. Waiting for review

    Preflight, then submit

    Preflight audits the whole version and reports every blocker with the fix. If this app's first in-app purchases are pending, submit aborts on purpose: only the website can bundle those with a version.

    release_preflight · submit_for_review

  7. Ready for sale

    Release, or roll out over 7 days

    Outward-facing calls require an explicit confirm flag, so an agent cannot ship to the public by accident.

    release_version · manage_phased_release

Answers

Common questions, answered directly

How is this different from an MCP server that wraps the API?

Wrappers expose Apple's endpoints one to one, which can mean hundreds of tools. That fills an agent's context and leaves the sequencing to it. This server ships 41 opinionated tools that each complete a job: one call sets an age rating by merging the full declaration set, one call prices a subscription across every territory and adds the trial, one call audits a version before submission.

What does it actually cost?

Nothing, for the first seven days. Ask your agent to run asc_start_trial and every tool unlocks for a week, no card, nothing to cancel. After that Pro is $9 per month through Polar, cancel any time. Six tools stay free with no asc-mcp account: the setup check, the playbook, the trial starter, listing apps, app details, and review status. The first three need nothing at all. The other three read from App Store Connect, so they need your own Apple API key, the same one every other tool here uses.

Where does my API key go?

Nowhere. The .p8 stays on your machine, JWTs are signed locally, and calls go straight from your computer to api.appstoreconnect.apple.com. Nothing proxies through this project. The only network call it makes elsewhere is a license check that sends your license key, not your credentials.

One narrow exception, and only when you call asc_start_trial: that request sends the email address you give it, so the key can reach you, and a SHA-256 hash of your Issuer ID computed on your machine, so one Apple developer account cannot take unlimited trials. The Issuer ID itself, the Key ID and the .p8 are never transmitted. Both values are covered by the privacy policy, and you can delete them at any time.

Can an agent submit or release my app by mistake?

No. submit_for_review, release_version, and upload_binary each refuse to run without an explicit confirm flag, so an agent has to be told twice. Reviews are the same: the reply tool writes a draft and never posts it.

Has this shipped a real app?

Yes. The control plane drove a 1.0 submission end to end in June 2026, including metadata, age rating, build attach, screenshots, three in-app purchase products priced across 175 territories, and the submission itself. Every limitation listed on this page was found by hitting it live, not by reading the docs.

Pricing

Try it on your own app first.

Every tool, free for seven days, without a card. Ask your agent to run asc_start_trial and it unlocks in the same conversation, no restart.

Free

$0

  • asc_start_trial, 7 days of everything below, no card, nothing to cancel
  • asc_setup_check, diagnoses your setup with a live authenticated call
  • asc_guide, the full playbook per flow with manual steps flagged
  • list_apps, app_details, review_status
  • No asc-mcp account, no signup, no card. Three of the six need nothing at all; the other three read from Apple with your own API key
See setup steps

Pro

$9 per month

  • All 41 tools, including the full write and control plane
  • Metadata, screenshots, builds, TestFlight, submit, release, phased rollout
  • Subscriptions and in-app purchases, priced and localized in one call
  • Reviews, sales reports, preflight audits, keyword and competitor intelligence
  • Cancel any time in Polar. Your license key is emailed and recoverable.
Get Pro, $9 per month

Lost your key? Recover it here.

Your .p8 never leaves your machine, and no App Store Connect data passes through this project. Privacy · Terms. This control plane drove a real 1.0 submission end to end in June 2026. Questions go to a person: povkonop@gmail.com.

What $9 buys that free does not

Every other App Store Connect MCP server is free, and two of them expose far more tools than this one. That is the honest comparison, so here it is.

ProjectPriceToolsWhat it is
asc-mcp (@pofky/asc-mcp, this project) $9 per month, 6 tools free with no expiry 41 Tools shaped like jobs, a preflight audit before you submit, and a maintained record of what Apple's API refuses to do at all
Heimdall Free, MIT 890 Generated from Apple's OpenAPI spec across 13 profiles, plus macros and a confirm-before-write flag
zelentsov-dev/asc-mcp Free, MIT 502 Generated across worker groups, and it covers Xcode Cloud, which this server does not
fastlane Free, MIT Not applicable The incumbent CLI. Ruby toolchain and lane files. Not an MCP server, so an agent reaches it by shelling out and parsing text rather than by calling a typed tool
App Store Connect Included with the $99/year Apple Developer Program Not applicable Apple's own console, in a browser, by hand

Competitor tool counts, licences and prices read from each project on 7 September 2026. These projects ship fast and the counts change; the links go to the source so you can check today's numbers yourself.

So why pay. Not for the tool count, which is a losing number here and always will be: a generated server gets one tool per endpoint for free. You pay for the part that cannot be generated, which is knowing what Apple will not let you do. The App Privacy label, EU trader status, the first in-app purchase of an app, and the app record itself cannot be created or set through the App Store Connect API at all, no matter which client you point at it, and finding that out costs a release. This server flags every one of them inline, before you start, and keeps the list current by hitting the live API and being refused. Read the list, it is public and it is the product. The six free tools include asc_guide, which serves that same list to your agent mid-task, so you can check the claim before paying anything.

Setup

Three steps, about five minutes

On Claude Desktop, skip all of it. Download the .mcpb bundle and open it. Claude installs it in one click, asks for your Issuer ID, and lets you pick your .p8 with a file picker. No config file, no restart. The steps below are for every other client.

  1. Create an App Store Connect API key. In App Store Connect, open Users and Access, then Integrations, then App Store Connect API. Generate a key with the App Manager role and download the .p8. Apple only lets you download it once. Drop it in Apple's standard folder and the Key ID is read from the filename. 
    mv ~/Downloads/AuthKey_*.p8 ~/.appstoreconnect/private_keys/
  2. Run init. It finds the key, asks for your Issuer ID and optional Pro key, and prints a paste-ready config block. Add --write and it merges the block into your client config for you, after backing it up. 
    npx @pofky/asc-mcp init --write
  3. Restart your client and check. Ask your agent to run the setup check. It verifies the key, the Issuer ID, a live authenticated call, and your license tier, and prints the exact fix for anything wrong. 
    npx @pofky/asc-mcp doctor

Works with Claude Code, Claude Desktop, Cursor, Windsurf, Cline, and any other MCP client that speaks stdio. Requires Node 18 or newer. Building and uploading a binary additionally needs a Mac with Xcode.

FAQ

What the App Store Connect API cannot do

This list matters more than the feature list. Anyone who tells you an agent can do all of App Store Connect has not tried these:

Create an app record

Forbidden for API keys. Create it once on the website, then everything after is automatable.

Set the App Privacy nutrition label

The data usage resource is not public. set_privacy_nutrition returns the checklist and the deep link.

Declare EU trader status

No API attribute exists, and it is a legal declaration. set_eu_trader_status returns the steps.

Submit an app's first in-app purchases

Apple requires the first products to be submitted with the version, which only the website can do. submit_for_review detects this and stops rather than orphaning your version. Later products submit fine over the API.

Post a public reply to a review

Reading reviews is in the API, replying is not. draft_review_response writes the reply for you to paste.

Use Xcode cloud signing with a least-privilege key

It fails with a permissions error. setup_app_store_signing creates real distribution profiles and an ExportOptions.plist for manual signing instead, which works.