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.
| Approach | Fits when | Where the work shows up | Hard to change later |
|---|---|---|---|
| Build under the client's account from the start | The client already has developer accounts, or can enroll alongside you | One-time invitation into their team | Almost nothing |
| Publish under your account, transfer later | The client's enrollment won't finish in time, or you want review cleared first | Checking transfer conditions and re-pointing every linked setting | Sign in with Apple users, revenue reports |
| Keep publishing under your account | You're contracted to run the app long term | Defining responsibility, and an exit path if the client leaves | The 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.
| Condition | Where it stalls | How to check |
|---|---|---|
| At least one version has been released on the App Store | A brand-new app that has never shipped | The app list in App Store Connect |
| No version is waiting for review, in review, or pending release | Trying to transfer with a submission still open | Status of the latest version |
| The app isn't offered for pre-order | Pre-order apps | Pricing and availability |
| In-app purchase product IDs don't collide with another app in the recipient's account | The client already ships an app with a similar ID scheme | Lay both product ID lists side by side |
| Both sides have accepted the latest agreements | The client hasn't accepted an updated agreement | Agreements, 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 over | Do this before the transfer |
|---|---|
| Earnings, payments, and bulk export reports | Download them and keep your own copy |
| Orders created before the transfer | Refunds stay with the original account; tell the client how long that lasts |
| Closed testing tester groups | Recreate them on the receiving side and re-invite testers |
| Google Analytics, Firebase, and other links | Write 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 credentialsto 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 3The 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.
| Symptom | Likely cause | How to check | Fix |
|---|---|---|---|
| App Store Connect won't let you start the transfer | Latest version in review or pending, or an unaccepted agreement | Version status and the Agreements page | Wait for review to finish, have both sides accept, then retry |
| Push notifications stop arriving | The APNs key still belongs to the sender's team | Team ID on the key registered with your push server | Create a key in the recipient's team; register it with the server and EAS |
| Existing Sign in with Apple users look like new users | Pre-transfer sub wasn't stored, or the 60-day window passed | Whether the user table holds the old sub | If stored, migrate through the transfer process; if not, match on another signal such as email |
| The next EAS build fails on credentials | eas.json still holds the sender's Team ID | The submit lines from the script above | Switch to the recipient's Team ID and regenerate with eas credentials |
| Play closed testing shows zero testers | Tester groups don't transfer | Testing tracks on the receiving account | Recreate the groups and resend opt-in links |
| Analytics stop on the transfer date | Firebase config still points at the sender's project | project_id in google-services.json | Replace 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:
- Do you already have an Apple Developer Program membership and a Google Play developer account?
- If not, will you enroll as an individual or an organization? (The enrollment name appears as the seller on the store.)
- From when will you manage revenue and billing yourselves?
- 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.