asc owns the build rail.MetaRun runs the store.

asc is a fast, free, open-source CLI that automates App Store Connect from the terminal, and it is genuinely good. MetaRun is a hosted platform whose tools an agent, a script, or a dashboard can drive. They overlap less than they appear to: the honest comparison is about where your keys live and what that makes possible.

Where asc wins

The road from source code to uploaded binary: archiving, exporting, code signing, notarization, certificates and profiles, build upload, Xcode Cloud triggers, CI recipes. If the job ends when the binary is on Apple's servers, asc is excellent and free.

Where MetaRun wins

Everything after the build exists: pricing across 175 territories on affordability indexes, listings in every locale, a screenshot studio that renders and publishes, releases and submission, reviews, ASO tracking, AI-assistant visibility, an AI operator, and background automation. Every write previews first and is revertible from history.

The correct setup

asc uploads the build; MetaRun attaches it, sweeps what would block submission, and submits. Our release-handoff skill teaches a coding agent exactly this handoff. Running both is not a compromise; it is the correct architecture.

Dimension by dimension

Dimensionasc (App Store Connect CLI)MetaRun
Where your Apple key livesOn each machine that runs it: keychain locally, config in CI. Every laptop and runner holding the .p8 is store-wide write access.Uploaded once, envelope-encrypted server-side. Machines hold revocable personal access tokens; losing one costs one revoke.
Build, sign, uploadFull coverage: archive, export, codesign, notarize, upload .ipa/.pkg, Xcode Cloud, certificates and profiles.Deliberately none. MetaRun starts where the processed build appears in App Store Connect.
Store presence depthMetadata and screenshot upload from local files; keyword audits; TestFlight management.245 tools: pricing engines (PPP, Big Mac, Spotify), per-locale listing editing, server-rendered screenshot generation and publishing, subscriptions and offers, reviews, ASO with measured Apple analytics, answer-engine visibility.
Safety model for writesNon-interactive by design, JSON-first; a --confirm flag on publish. The API takes what a correct command says.Structural: every mutation is a preview/apply pair. The preview returns a before/after diff and a confirm token; apply rejects if the store drifted. Submission needs an explicit acknowledgment on top.
UndoWhat the App Store Connect API offers: none.Every applied change lands in change history with its source; most changes revert in one tap through the same preview pipeline.
While you sleepNothing runs without a machine that holds your key awake and online.Hosted credentials make background work possible: the ASO Sentinel watches ranks, scheduled promo texts publish themselves, findings wait for you.
AI agents26 prose skills teach agents to compose CLI flags and parse output.Typed tools over MCP (schemas validated server-side) plus five open-source mission skills; the agent never sees a credential and cannot skip a preview.
InterfaceThe terminal.Terminal (npx metarun), IDE agent (MCP), dashboard, and MILO: chat and voice over the same tools.
Price and licenseFree, MIT, open source.Paid SaaS (from $15/mo, free trial). The parts that cost us money to run are the parts a free local binary cannot do.

01 · Briefing

The real difference is architectural, not feature count

asc is a local process. That is its strength: it can drive Xcode, touch the keychain, sign binaries, and upload gigabytes, because it lives on your Mac. It is also the boundary: a local process acts only while a machine holding your private key is awake, online, and invoking it. The key itself is store-wide, does not expire, and must be provisioned onto every machine and CI runner that automates anything.

MetaRun is the other architecture. Your App Store Connect key is uploaded once and held envelope-encrypted on the server; everything else authenticates with narrow, revocable tokens. That single decision is what makes the rest possible: background monitoring, scheduled publishing, a change history with undo, a web dashboard, and an AI operator that can act on your behalf without your laptop open. None of that is a feature a CLI could add; it is what being hosted means.

02 · Briefing

What asc does better, stated plainly

Everything between your source code and an uploaded binary. MetaRun does not archive, export, sign, notarize, or upload builds, and does not manage certificates, provisioning profiles, or bundle identifiers. A browser-based platform structurally cannot do those things well, and pretending otherwise would make this page worthless. asc also covers Apple Ads campaign management and Xcode Cloud triggering, which MetaRun today does not.

If your entire need is 'scriptable API access from my Mac and CI, free', asc is the right tool and you should use it.

03 · Briefing

What the hosted architecture buys you

Safety that survives automation. MetaRun's writes are preview/apply pairs: the preview computes the exact before/after and mints a confirm token over it; the apply re-validates and rejects if the store changed underneath. A script, an agent, or a tired human at 2am physically cannot skip the look-before-write. Every applied change is recorded with its source, and most are revertible in one tap: a wrong bulk reprice is an undo, not an incident.

Work that happens without you. The ASO Sentinel scans tracked keywords and rival listings in the background and files findings. Promotional text can be scheduled and publishes itself. These are impossible for any tool whose credentials live on your laptop, which is why no local CLI offers them.

Depth on the store side. Repricing 175 territories on a purchasing-power index with tier snapping, editing every locale side by side, rendering localized screenshot sets server-side and publishing them in order, managing subscription offers across the customer lifecycle: these are engines with judgment encoded, not endpoint wrappers.

04 · Briefing

The correct setup uses both

Let asc (or fastlane, or Xcode Cloud) own the build: archive, sign, upload. The moment the build lands in App Store Connect, MetaRun takes over: attach it to the version, run the readiness sweep that names every blocker per language, stage what is missing, and submit with an explicit acknowledgment. Our open-source release-handoff skill teaches a coding agent this exact sequence, so 'the build is up, ship it' is one sentence in your IDE.

There is no lock-in tax in this split: asc stays free and yours, MetaRun's writes are all previewed and revertible, and your listing data is exportable in the fastlane deliver format either way.

Questions, answered straight

Is asc (the App Store Connect CLI) good?

Yes, genuinely: it is fast, free, MIT-licensed, and the best tool for scripting the build rail (archive, sign, upload, TestFlight, Xcode Cloud) from a terminal or CI. This page exists because people evaluate it alongside MetaRun, not because it is bad.

Can I use asc and MetaRun together?

That is the recommended setup: asc uploads the build, MetaRun attaches it to the version, sweeps submission blockers, and submits. The open-source release-handoff skill (github.com/metarun/metarun-skills) teaches a coding agent this handoff end to end.

Why pay for MetaRun when asc is free?

You are paying for the parts that require a server someone operates: credentials held encrypted so agents and background jobs can act safely, preview-gated writes with change history and one-tap undo, autonomous rank monitoring and scheduled publishing, pricing and screenshot engines, and an AI operator. A free local binary cannot offer those, at any price.

Does MetaRun upload builds or manage code signing?

No, deliberately. Archiving, signing, notarization, and build upload belong to local tools (asc, fastlane, Xcode Cloud) that can touch your Mac's keychain and toolchain. MetaRun starts where the processed build appears in App Store Connect and owns everything after.

Which is safer to let an AI agent use?

Structurally different answers. With a local CLI, the agent's machine holds your store-wide .p8 key and a correct-looking command executes immediately. With MetaRun, the agent holds a revocable token, never sees credentials, and every write must pass a preview whose confirm token is bound to the exact change; drift invalidates it.

Does asc have features MetaRun lacks?

Yes: everything build-side (signing, certificates, profiles, notarization, build upload, Xcode Cloud triggers) plus Apple Ads campaign management. MetaRun's coverage begins at the store presence layer: listings, pricing, screenshots, releases, reviews, ASO, and AI-assistant visibility.

Go deeper