For indie app developers

How to automate App Store Connect and Google Play Console tasks

App Store Connect and Google Play Console both let a program read and write much of what a person can otherwise only do by hand inside their dashboards: a version's review state, its per-language metadata, an in-app purchase's status, or a store listing's live content, all reachable through each store's own API.

No credit cardFree tier with 200 AI creditsCancel anytime

5
kinds of workflow trigger
10
store and product events tracked
20
ready-made workflow templates
The short answer

Having that access is not the same as using it unsupervised. Apple's own review of a submitted version happens after the fact, on Apple's side, and a check that catches a problem, an in-app purchase not ready, a demo account left blank, is more useful run before a submission than found in a rejection afterward. Forvibe's Workflows feature connects a store event, a fixed schedule, or the moment right before an action like a submission or a publish, to a chosen sequence of reads, checks and writes, and lets specific writes, submitting a version for review and publishing a listing among them, pause for a person to approve the exact change before it reaches the store. Automating a release chore safely comes down to the same classification either way: which parts only ever read, which parts write something a customer or a reviewer will see, and which of those writes still need a person to say yes before they go out.

The symptoms of doing every store update by hand

Release notes get written once in English and pasted into every language's What's New field unchanged, or forgotten entirely until someone remembers right before a version gets submitted.

A version reaches Apple with an in-app purchase still sitting in a state review won't accept, or with the demo account field empty even though the app told Apple it needs one, and the submission is lost to a rejection that had nothing to do with the app itself.

A rejection notice or a one-star review sits unread over a weekend, because checking App Store Connect or the Reviews page happens whenever someone remembers to look, not the moment either one actually happens.

What store APIs allow to be automated, and where a human approval still belongs

Both stores' own APIs let a program read and write what a person otherwise does by hand. Forvibe's Workflows automate that, but any write a customer or reviewer would see can pause for a person's approval before it ships.

Five kinds of trigger
A workflow starts from a manual run, a store event, a schedule, a delay after an event, or a pre-action guardrail.
Writes hit a short list
A write step can only touch a fixed set of fields: version text, app name, review state, a listing, or a reply.
Submitting and publishing ask first
Submitting a version for review and publishing listing changes both default to pausing for a person's approval before they run.
Approval shows the real values
Approving means seeing the exact text or values about to be written, not a summary, and requires a signed-in org role that can write.
A guardrail only blocks Forvibe
A guardrail can stop a submission started in Forvibe's dashboard, or a listing publish started in the dashboard or through its MCP server, but never a change made directly in App Store Connect.
Read the full explanation

App Store Connect's own API documentation describes exactly this kind of automation: Apple says it lets a developer 'automate tasks across developer tools, such as App Store Connect,' and lists creating new versions, managing phased releases for version updates, submitting a version for review, managing in-app purchase metadata, and maintaining a product page's description, screenshots and previews among what the API covers. Google's Play Developer API covers the same ground for the other store: Google describes it as letting a developer 'automate frequent tasks having to do with app production and distribution,' including uploading new app versions, releasing them, and creating and modifying store listings. Forvibe's Workflows feature is built on that same surface, split between reading, writing, and waiting for a person. A workflow starts from one of five kinds of trigger: a person pressing Run, one of ten store and product events Forvibe already tracks, among them a new version appearing, a version being submitted or going live, an in-app purchase's review state changing, a new customer review, or an app being connected, a fixed schedule, a fixed delay counted from one of those same events, or a check that runs synchronously in the moment right before a specific action and can refuse to let it proceed. From there, a step either reads something, a version, its per-language fields, an in-app purchase's state, a review submission, an existing customer review, or writes to one of a short, fixed set of things: a version's per-language text, the app's name and subtitle, a version's review state, its copyright and App Review contact details, a store listing on either platform, or a reply to one review. Any write step can be set to pause for a person's approval before it runs; submitting a version for review and publishing listing changes both default to asking, and removing a version from review cannot be set to skip asking at all. That approval is not a rubber stamp: the exact values about to be written are resolved and shown before anyone decides, deciding requires being signed into the organization with a role that can write to it rather than just clicking a link from an email, and a request nobody answers fails the run instead of going through by default. A guardrail, the trigger that runs before an action rather than after one, only ever reads and checks, never writes, because a person or process is left waiting on its answer, and it has thirty seconds to reach a verdict. It can only actually stop an action taken through Forvibe itself: publishing listing changes is checked whether it starts from the dashboard or from Forvibe's own MCP server, and submitting a version for review is checked when it starts from the dashboard. A change made directly inside App Store Connect's own web interface can't be intercepted either way. It's only noticed within about fifteen minutes, by the same poller that checks App Store Connect for changes made outside Forvibe, and it can raise an alert instead of a block. Google Play has no equivalent after-the-fact check at all. Because neither store gives a reliable way to confirm whether a request that appears to have failed actually went through, a write step that dies mid-run is never retried automatically; it fails the run and says so, so the actual state gets checked directly rather than assumed.

The sequence for turning a recurring store task into a workflow

  1. Pick one recurring task, not the whole release process

    Start from a single, well-defined chore you already do the same way every time: translating release notes, checking that every in-app purchase is ready, or replying to five-star reviews, rather than wiring an entire release into one automation on the first attempt.

  2. Decide what should start it

    A recurring chore usually starts from one of three places: something changing in the store, a new version, a submitted review, a rejection, a fixed schedule, or the moment right before an action you're about to take yourself.

  3. Separate what only reads from what actually changes something

    A step that only reads, a version's state, a review's text, carries no risk on its own. A step that writes back to the store is worth a second look, since a customer or reviewer will actually see it.

  4. Decide where a person still has to say yes

    A write step can pause, show the exact text or values it's about to send, and wait for a specific person to approve. Reserve that for anything unproven, or written in your own voice, like a review reply or a new listing.

  5. Test it before anything reaches the store

    Run it once against a real app with its write steps held back rather than sent, read what it would have done, then let it run for real.

  6. Or start from a template instead of a blank canvas

    Forvibe ships 20 ready-made workflows, grouped by what each is for: setup, watching for events, guarding a release, listing upkeep, or writing on your behalf. Every card says plainly whether it changes anything or only reads.

How the two approaches compare

Doing each release by hand
Running it as a workflow

Release notes across languages

Write them once, then translate and paste each language in yourself, or leave some blank

Picked up automatically when a new version appears, translated into every language it already has, and written in only where a field is still empty

Checking in-app purchases before you submit

Open each product yourself and check its review state before submitting

Checked the instant you try to submit; if anything isn't ready, the submission is refused and you're told how many products need attention

Noticing a rejection or a low-rated review

Whoever next opens App Store Connect or the Reviews page happens to see it

An alert and an email the moment it happens

Listing drift over time

Caught only on an occasional re-read of your own listing

Checked on a repeating schedule, with what it finds summarized each time

What still needs a person

Every single change, since you're the one making it

Whatever you choose, shown with the exact text before it ships; submitting and publishing ask by default

Questions, answered

Ready to get started?

Create a free Forvibe account and put this into practice.