How to use App Store Connect (ASC) CLI

If you've ever spent an afternoon clicking through App Store Connect to update metadata, upload a build, or — god forbid — localize your app listing into 15 languages, you know the pain. The web UI is slow, repetitive, and to be cumbersome for actual workflows. It almost doesn't feel like an Apple product. Using something like Helm, greatly improves the experience of working with App Store Connect, but wouldn't it be nice to just ask agents to do these things?

That's where ASC CLI steps in. It's an unofficial, open-source command-line tool for App Store Connect APIs, that lets you manage your entire App Store workflow from the terminal. Builds, submissions, metadata, localizations, TestFlight — all of it. And when you pair it with AI agent skills, things get really interesting. But we'll get to that in a bit.

Let's set it up first.

Step 1: Install ASC

One line, thanks to Homebrew:

brew install asc

ASC is in very active development and doesn't auto-update, so get in the habit of running this every now and then:

brew upgrade asc

Step 2: Connect to App Store Connect

You'll need an App Store Connect API key — the same kind you use for RevenueCat, Fastlane, or any other service that talks to the App Store Connect API.

2.1 Create an API key

Head to Users and Access → Integrations → App Store Connect API in App Store Connect and create a new key:

It'll ask you about access level. Admin gives you full access to everything. App Manager is enough if you're only managing app metadata and builds.

Once created, download the .p8 key file immediately. Apple only lets you download it once — if you lose it, you'll need to generate a new one. I'd recommend dropping it straight into 1Password or your preferred secret manager.

You'll also need two values from this page:

1. Issuer ID
2. Key ID

Here's where to find them:

2.2 Authenticate the CLI

Now wire it all together. ASC can store credentials in a few ways — the simplest is a local config file:

asc auth login \
  --bypass-keychain \
  --name "YourAppsName" \
  --key-id "ABC123" \
  --issuer-id "DEF456" \
  --private-key /path/to/AuthKey.p8

That's it. You're connected. But let's still break down what each part does. asc auth login tells the CLI you want to save a new set of credentials. --bypass-keychain stores them in a simple local file instead of the macOS Keychain — less hassle. --name is just a label so you can tell your credentials apart if you have multiple keys. --key-id and --issuer-id are the two values you copied from the App Store Connect API page. And --private-key points to the .p8 file you downloaded. Once you run this, every future ASC command is automatically authenticated. you don't need to pass these values again.

What can you do with it?

Let's run through a few everyday workflows to give you a feel for how ASC works before we get to the really powerful stuff. In reality you would not probably even use these in the command line yourself, since they are pretty difficult to remember, but let's still go through them so when we get to the skills section, we know what is actually happening under the hood.

Upload a build

Archive your app from the command line and upload it straight to App Store Connect. The first command here is not related ASC CLI directly, but it's needed so we can upload a build without Xcode.

xcodebuild clean archive \
  -scheme "YourScheme" \
  -configuration Release \
  -archivePath /tmp/YourApp.xcarchive \
  -destination "generic/platform=iOS"

xcodebuild -exportArchive \
  -archivePath /tmp/YourApp.xcarchive \
  -exportPath /tmp/YourAppExport \
  -exportOptionsPlist ExportOptions.plist

Then hand the IPA to ASC:

asc builds upload --app "APP_ID" --file "/tmp/YourAppExport/YourApp.ipa"

Submit for review

Once your build has finished processing, one command sends it off:

asc submit create --app "APP_ID" --version "1.2.0" --build "BUILD_ID" --confirm

Localize your store listing

Pull down your existing localizations, translate them however you like, and push them back up:

asc localizations download --version "VERSION_ID" --path "./localizations"
# ... translate the files ...
asc localizations upload --version "VERSION_ID" --path "./localizations"

These are just the basics. ASC has commands for TestFlight groups, encryption declarations, pricing, certificates, and a lot more. But here's where it gets fun.

ASC CLI + AI Agents = Magic

This is the part I'm most excited about. Rudrank didn't just build a CLI — he also built 19 skills that teach AI agents how to use it. Install them and your AI agent suddenly knows how to manage your App Store presence.

Get started with one command:

npx skills add rudrankriyam/app-store-connect-cli-skills

Pick which AI tool you want the skills installed for (I went with Claude), and you're good to go. Instead of memorizing flags and looking up build IDs, you just talk to your agent in plain language.

The real power is that these skills compose. In a single conversation, you could say: "Build and upload my app, check it's ready for review, localize into Japanese, Korean, French, and German, and show me what's crashing in the latest TestFlight build." That one prompt kicks off four different skills — build, preflight, localize, crash triage — and walks you through an entire release cycle without leaving your editor.

asc-xcode-build

Handles the entire build → archive → export pipeline. No fiddling with xcodebuild flags or hand-crafting ExportOptions.plist files. Just tell your agent "build my app and upload it" and it handles the rest.

asc-release-flow

An end-to-end release skill for both TestFlight and App Store, covering iOS, macOS, visionOS, and tvOS. It knows the right order of operations — create a version, attach a build, fill in metadata, submit.

asc-localize-metadata

This one is a game-changer. It uses LLM-powered translation to localize your App Store descriptions, keywords, what's new text, and subtitles across multiple locales. It knows the character limits (30 for subtitles, 100 for keywords, 4,000 for descriptions) and enforces them automatically.

asc-crash-triage

This skill pulls your TestFlight crash reports, groups them by signature, device, and build, and gives you a plain-language summary of what's breaking and why.

asc-subscription-localization

If you're using RevenueCat (or just have a lot of in-app purchases), this one bulk-updates subscription and IAP display names across every App Store language at once.

Wrapping up

I recently one shotted a small command line app with Claude and ASC CLI, and the only time I had to jump into App Store Connect was to create the app submission. This step you seem to be able to already automate as well, at least what I've been following the ASC CLI skills repo. Funny thing was that Claude even ended up creating a screenshot of the app itself and uploading it, which to be honest was a pretty bad screenshot, but still a screenshot.

ASC CLI is one of those tools that makes you wonder why you put up with the web UI for so long. The CLI on its own is already a huge time-saver, but the AI skills are what really set it apart. Being able to say "localize my app into Japanese, Korean, and French" and have it just happen — with character limits enforced and a review step built in — is a massive time saver. You can then use that time to obsess over the UX of your app instead, which is what you should be doing.

Give it a try: brew install asc. Your future self will thank you.