◉RORK LABJP
●MCP — Rork now lets you add and manage your own MCP servers inside Plugins (11/21)●2.5 ROUTE — From 12/1, apps calling gemini-2.5-flash are routed to 3.5 Flash-Lite and billed at its rates (9 days left)●CHANNEL — Users report Android notification channel reads and writes failing in Expo Go●NEW — New: three clues to check before replying to a stuck-on-splash review●EXPORT — Export your projects before you downgrade or cancel a plan●SONNET 4.5 — Apps that call Sonnet 4.5 through the API should switch before it retires on 11/30●MCP — Rork now lets you add and manage your own MCP servers inside Plugins (11/21)●2.5 ROUTE — From 12/1, apps calling gemini-2.5-flash are routed to 3.5 Flash-Lite and billed at its rates (9 days left)●CHANNEL — Users report Android notification channel reads and writes failing in Expo Go●NEW — New: three clues to check before replying to a stuck-on-splash review●EXPORT — Export your projects before you downgrade or cancel a plan●SONNET 4.5 — Apps that call Sonnet 4.5 through the API should switch before it retires on 11/30
Articles/Business
⟐ Business/2026-10-08Beginner

Before You Build a Client's App in Rork, Decide Who Owns the Store Account

When you deliver a Rork-built app to a client, the first decision is whose developer account publishes it. Apple, Google, and Expo rules for transfers as of November 2026: what must be true first, what carries over, what breaks afterward, a troubleshooting table, and a script that lists every setting tied to your name.

Rork620app deliveryApp Store Connect17Google Play Consoleapp transferclient work

I was reading Apple's and Google's transfer help pages side by side one evening when I caught an assumption I hadn't noticed I was carrying. Somewhere in the back of my mind, a transfer was a button you press at the end. The further I read, the longer the list grew: conditions that have to be true before you press it, and settings that quietly break after you do.

As an indie developer, I have only ever published my own apps from my own accounts, so I have never moved an app into someone else's name. I'm writing with that limit in plain view. I read the official pages from Apple, Google, and Expo, and I ran the one piece I could check myself, a small audit script, against a sample project. Please read this as a way to decide early, not as a transfer diary.

The short answer first: build the client's app under the client's developer account from day one. It leaves the least to undo. The rest of this piece is the reasoning, and the sequence I'd follow if you really must publish under your own name first. Everything below reflects the official help pages as of November 2026.

Three ways to hold the account

When you build an app in Rork for someone else, there are roughly three ways to decide whose store account publishes it.

ApproachFits whenWhere the work shows upHard to change later
Build under the client's account from the startThe client already has developer accounts, or can enroll alongside youOne-time invitation into their teamAlmost nothing
Publish under your account, transfer laterThe client's enrollment won't finish in time, or you want review cleared firstChecking transfer conditions and re-pointing every linked settingSign in with Apple users, revenue reports
Keep publishing under your accountYou're contracted to run the app long termDefining responsibility, and an exit path if the client leavesThe seller name on the store stays yours

The decision fits in one sentence: if the client can finish enrollment within about two weeks, choose the first; choose the second only when they can't; keep the third for real operations contracts. Organization enrollment with Apple can take a while to verify, so asking how far along the client is before you sign anything keeps this decision steady.

If you do go with the second option, what matters is not whether a transfer is possible but being able to explain, at quote time, what carries over and what gets cut.

Apple: what must be true, and where it stalls

The "App transfer criteria" page in App Store Connect Help lists the rules. These are the ones that made me stop and reread, paired with how to check each.

ConditionWhere it stallsHow to check
At least one version has been released on the App StoreA brand-new app that has never shippedThe app list in App Store Connect
No version is waiting for review, in review, or pending releaseTrying to transfer with a submission still openStatus of the latest version
The app isn't offered for pre-orderPre-order appsPricing and availability
In-app purchase product IDs don't collide with another app in the recipient's accountThe client already ships an app with a similar ID schemeLay both product ID lists side by side
Both sides have accepted the latest agreementsThe client hasn't accepted an updated agreementAgreements, Tax, and Banking

After a transfer the app stays on the App Store, and its ratings, reviews, and bundle ID come along. And a bundle ID can't be changed once you've uploaded a build. That's the item to settle with the client at the very start, ideally something that reads as their brand.

The help pages also name what needs re-pointing:

  • Auto-renewable subscriptions: the sender generates an app-specific shared secret before starting the transfer and hands it over.
  • TestFlight: stop all beta testing and remove builds and testers first.
  • Push notifications, Apple Pay, iCloud, Game Center: each has its own reconfiguration steps on the recipient's side.
  • Sign in with Apple: user identifiers are scoped to a team, so users have to be migrated across the transfer. The window for that migration is 60 days.

Sign in with Apple is the one I'd plan for earliest. If your server never stored each user's pre-transfer identifier (the sub), there's nothing to map onto the new team's identifiers. Apple's developer forums carry a steady stream of threads from people who discovered this after the fact. If the app you're building for someone has sign-in, design the server to keep sub from the first day.

Apple also notes that once a transfer completes, the app disappears from the sender's account. Exporting what you need beforehand isn't caution, it's part of the procedure.

Google Play: know what doesn't carry over

On Google Play, the sender requests the transfer and the owner of the receiving account approves it. The receiving account must be fully registered, and a new one carries the registration fee. Processing can take some days, so I wouldn't file the request right before a launch date.

Users, statistics, ratings and reviews, subscriptions, and submitted app content declarations carry over. These do not:

Doesn't carry overDo this before the transfer
Earnings, payments, and bulk export reportsDownload them and keep your own copy
Orders created before the transferRefunds stay with the original account; tell the client how long that lasts
Closed testing tester groupsRecreate them on the receiving side and re-invite testers
Google Analytics, Firebase, and other linksWrite down every integration so it can be reconnected afterward

An app whose only products are in-app items gets unpublished after the transfer and has to be republished. Android developer verification has also been rolling out country by country in 2026, so it's worth confirming the receiving account's verification status before you start.

Expo and EAS: your name lives outside the stores too

It's easy to watch only the store side and forget the pipeline that builds and ships the app. A project exported from Rork carries your Expo account name (owner) and an EAS project ID. Expo's "App transfers" documentation covers moving a project to another Expo account.

What I want to underline is that credentials don't all belong to the same party:

  • iOS distribution certificates and push keys (APNs keys) belong to the Apple developer team. A new team means creating new ones on the recipient's side.
  • The Android upload keystore usually lives in EAS, and you can download it with eas credentials to hand over. With Play App Signing, the app signing key itself stays with Google.
  • The expo-updates URL is tied to the project ID. Before moving the project, note which URL the shipped builds are pointing at.

Listing the settings tied to your name

Help pages can't tell you where your own account has crept into a real project. My first version of this script only read the production submit profile, and it missed a Team ID of mine sitting in a differently named profile. So I rewrote it to read every profile, plus entitlements, Sign in with Apple, and expo-updates.

// audit.mjs v2 — usage: node audit.mjs <project folder>
// Reads app.json and every profile in eas.json, and lists what a transfer touches
import { readFileSync, existsSync } from "node:fs";
import { join } from "node:path";
 
const dir = process.argv[2] ?? ".";
const has = (f) => existsSync(join(dir, f));
const json = (f) => (has(f) ? JSON.parse(readFileSync(join(dir, f), "utf8")) : null);
 
if (has("app.config.js") || has("app.config.ts")) {
  console.log("NOTE    app.config.js/ts found. Values resolve at runtime; check them with npx expo config");
}
 
const app = json("app.json")?.expo ?? {};
const eas = json("eas.json") ?? {};
const rows = [];
const add = (kind, label, value) => value && rows.push([kind, label, value]);
 
// Places your name lives (re-point these during a transfer)
add("REPOINT", "Expo owner", app.owner);
add("REPOINT", "EAS projectId", app.extra?.eas?.projectId);
add("REPOINT", "expo-updates URL", app.updates?.url);
for (const [name, p] of Object.entries(eas.submit ?? {})) {
  add("REPOINT", `submit.${name} Apple ID`, p.ios?.appleId);
  add("REPOINT", `submit.${name} Apple Team ID`, p.ios?.appleTeamId);
  add("REPOINT", `submit.${name} ascAppId`, p.ios?.ascAppId);
  add("REPOINT", `submit.${name} Play key file`, p.android?.serviceAccountKeyPath);
}
add("REPOINT", "Firebase iOS config", has("GoogleService-Info.plist") && "GoogleService-Info.plist");
add("REPOINT", "Firebase Android config", has("google-services.json") && "google-services.json");
add("REPOINT", "Apple entitlements", app.ios?.entitlements && Object.keys(app.ios.entitlements).join(", "));
add("REPOINT", "Sign in with Apple", app.ios?.usesAppleSignIn && "in use (store sub before transfer)");
 
// Places that must NOT change (they survive a transfer; changing them makes a new app)
add("KEEP   ", "iOS Bundle ID", app.ios?.bundleIdentifier);
add("KEEP   ", "Android package", app.android?.package);
add("KEEP   ", "URL scheme", app.scheme);
 
for (const [kind, label, value] of rows) console.log(`${kind} ${label}: ${value}`);
console.log(`--- repoint ${rows.filter((r) => r[0] === "REPOINT").length} / keep ${rows.filter((r) => r[0].trim() === "KEEP").length}`);

Here's the output on Linux with Node.js 22, against a sample project with two submit profiles, production and client:

REPOINT Expo owner: my-expo-name
REPOINT EAS projectId: 0000-aaaa
REPOINT expo-updates URL: https://u.expo.dev/0000-aaaa
REPOINT submit.production Apple ID: me@example.com
REPOINT submit.production Apple Team ID: ABCDE12345
REPOINT submit.production ascAppId: 1234567890
REPOINT submit.production Play key file: ./play-key.json
REPOINT submit.client Apple Team ID: ZYXWV98765
REPOINT Firebase Android config: google-services.json
REPOINT Apple entitlements: aps-environment
REPOINT Sign in with Apple: in use (store sub before transfer)
KEEP    iOS Bundle ID: com.example.sample
KEEP    Android package: com.example.sample
KEEP    URL scheme: sample
--- repoint 11 / keep 3

The split into REPOINT and KEEP is deliberate. Bundle ID, package name, and URL scheme survive a transfer, and changing them turns the app into a different app, so they belong on a "confirm unchanged" list rather than a to-do list. ascAppId is the numeric App Store app ID; I kept it as a line to confirm it matches what the recipient sees in App Store Connect. Projects that build their config in app.config.js can't be fully read this way, so the script prints a note and sends you to npx expo config instead.

Every REPOINT line becomes an item in the handover document.

Sorting out what breaks after a transfer

In practice, "something stopped working after the transfer" is the more common conversation than the transfer itself. Here's a table you can walk from the symptom.

SymptomLikely causeHow to checkFix
App Store Connect won't let you start the transferLatest version in review or pending, or an unaccepted agreementVersion status and the Agreements pageWait for review to finish, have both sides accept, then retry
Push notifications stop arrivingThe APNs key still belongs to the sender's teamTeam ID on the key registered with your push serverCreate a key in the recipient's team; register it with the server and EAS
Existing Sign in with Apple users look like new usersPre-transfer sub wasn't stored, or the 60-day window passedWhether the user table holds the old subIf stored, migrate through the transfer process; if not, match on another signal such as email
The next EAS build fails on credentialseas.json still holds the sender's Team IDThe submit lines from the script aboveSwitch to the recipient's Team ID and regenerate with eas credentials
Play closed testing shows zero testersTester groups don't transferTesting tracks on the receiving accountRecreate the groups and resend opt-in links
Analytics stop on the transfer dateFirebase config still points at the sender's projectproject_id in google-services.jsonReplace with a file issued from the recipient's project and rebuild

Common misunderstandings

"A transfer wipes the reviews." It doesn't. Both Apple and Google say ratings and reviews stay with the app. What disappears is the app from the sender's account.

"You can change the bundle ID to the client's during the transfer." You can't. After the first upload the bundle ID is fixed, and a transfer hands over the app with that ID. If the client's company name belongs in the ID, it has to be decided before the first build.

"Moving the store listing moves the build setup too." It doesn't. The store transfer, the Expo project and credentials, and Firebase links are separate jobs. Move only the listing, and the next update stalls at build time.

Four questions to ask before you quote

At first I treated the transfer as a one-time step at the very end, outside the estimate. Writing the troubleshooting table above changed that: more than half the work sits in preparing for the transfer and re-pointing things afterward. These days I hold to a simple line: the transfer is part of delivery, so it goes into the estimate, and ownership is decided before the contract. These are the four questions I'd ask:

  1. Do you already have an Apple Developer Program membership and a Google Play developer account?
  2. If not, will you enroll as an individual or an organization? (The enrollment name appears as the seller on the store.)
  3. From when will you manage revenue and billing yourselves?
  4. If something breaks after launch, who holds the account permissions?

Once those four are settled, "the client's account from day one" usually covers it.

The next place you'll get stuck

Once ownership is settled, the next wall is usually Apple's enrollment wait. If you're enrolling alongside the client, the order in the Apple-side steps Rork can't do for you clears the slowest steps first.

When you choose an ID that reads as the client's brand, run the script in names you can change and names you can't to make sure Rork's default ID isn't still in place. If an app has already shipped under an individual account and needs to move to an organization, moving an iOS app from an individual to an organization account lists what to remove first. And for Android apps distributed widely, checking the four countries where developer verification blocks new installs is worth a look alongside this one.

The first thing to do tomorrow

If you have a client project in progress, run node audit.mjs . in its folder once and count the REPOINT lines. That number is the most honest estimate I know of for how much a transfer will cost you.

Apple's and Google's procedures change from time to time, so when you actually transfer, please reread the current help pages first. That rereading is the one step I don't skip, case by case.

Share

Thank You for Reading

Rork Lab is ad-free, supported entirely by members like you. We publish practical guides daily with implementation code, benchmarks, and production-ready patterns. If you've found it useful, we'd love to have you on board.

  • ✦Copy-paste ready implementation code
  • ✦New advanced guides published daily
  • ✦$5/mo or $10 for lifetime access
View Membership →

If you found this article helpful, a small tip ($1.50) would mean a lot to us. Your support helps keep this site ad-free and covers server and hosting costs.

Related Articles

⟐ Business2026-07-19
Handing Over an App — What an App Store Transfer Carries, and What You Rebuild
A practical look at App Store Connect app transfers when selling or moving an app: the eligibility criteria, what carries over (ratings, subscribers, iCloud data), what you rebuild (TestFlight, APNs, merchant IDs), and the three places users actually feel the change.
⟐ Business2026-10-28
If You Want to Rename an App After Release, Sort What the Store Keeps From What You Redo. Before Choosing a Name, Look at a Trademark Search
Being able to save a name in App Store Connect is not the same as being allowed to use it. Here is what Apple and Google Play documentation actually says about renaming after release, a small script that finds the old name left inside your project, and the order I check things before settling on a name.
⟐ Business2026-10-25
It Looks Opaque, but App Store Connect Says the Icon Has an Alpha Channel — Checking the PNG Before You Upload
ITMS-90717 (Invalid large app icon) can fire on an icon that shows no transparency at all, because an alpha channel is enough. I built six sample PNGs to tell the cases apart, and share a stdlib-only checker and a flatten step.