The first build you upload fixes your bundle ID for the life of the app.

When does a bundle ID stop being changeable?

At the first build upload. App Store Connect Help's App information reference describes the Bundle ID as a unique identifier for your app that is used throughout the system, notes that a build is uniquely identified by the combination of the bundle ID, version number and build string, and then says plainly that you cannot change this property after you upload a build. The same entry marks it Important that the Bundle ID property must match the bundle ID you set in the Xcode project. So the field is editable right up to the moment it matters, and the thing that ends the editing is an action most people treat as routine.

Apple repeats the rule in the developer documentation and adds a consequence. The CFBundleIdentifier key in Bundle Resources carries an Important note: the bundle ID in the information property list must match the bundle ID you enter in App Store Connect, and after you upload a build to App Store Connect you can't change the bundle ID or delete the associated explicit App ID in your developer account. That second clause is the one people miss. The identifier is stuck on the app record and the App ID behind it is stuck in Certificates, Identifiers and Profiles, so you cannot tidy up by deleting the registration and starting again.

One page looks like it answers this and does not. The Required, localizable, and editable properties reference prints a table where Bundle ID has a tick under Required and nothing under Editable. Read the lead sentence before you lean on that: the Editable column means properties you can edit at any time without submitting a new version of your app, which is why Name is also blank there. The ticks are images with alt text, so this table comes back empty in a text extraction. Open the rendered page if you want to read it. The sentence that actually states the bundle ID rule is the one on the App information reference.

The format rules are looser than the folklore. Apple's CFBundleIdentifier documentation says the string must contain only alphanumeric characters, hyphens and periods, that you typically use a reverse-DNS format, and that bundle IDs are case-insensitive. Typically is Apple's word: a reverse domain is a convention, not a check. Three Apple pages that would say otherwise, Register an App ID in Account Help, the CFBundleIdentifier key, and Add a new app in App Store Connect Help, say nothing about what happens when the identifier you want is already registered to somebody else. All three were read on 21 October 2026. If you are creating records in bulk rather than by hand, the same values are what the app store connect api writes for you, with the same one-way door at the end.

Apple, App Store Connect Help, App information, read 21 October 2026, no last-updated date printed

Can you reuse a bundle ID from an app you removed?

Apple answers this in a warning box on the Remove an app page, and the answer has a condition in it. Remove an app and you lose ownership of the app name. Removed apps can only be restored if the name is not currently in use by another developer account. The SKU cannot be reused in the same organization. And, in Apple's own words, if you have uploaded a build, your bundle ID cannot be reused. The condition is worth reading twice. A record you created for a project that never shipped a single build is the one case where the identifier comes back to you.

Removal is also harder than it sounds. The same page says you must first remove the app from the App Store for all countries and regions, even if the app was never released, and remove any associated In-App Purchases from sale. Apps in Ready for Review, Waiting for Review, In Review, Metadata Rejected or Rejected cannot be removed at all, nor can an app that is being transferred or that is part of an app bundle. App bundles themselves cannot be removed. The SKU rule on the App information reference is the same shape as the bundle ID rule, one step earlier: you cannot change the SKU after you add the app to your account.

Removing an app is not the same as deleting it. Apple documents a restore path on the same page: open the status filter in Apps, choose Removed Apps, select the app, then click Restore App under Additional Information. If the app name is no longer available, the app cannot be restored. Removing and restoring both need the Account Holder or an Admin, which is the kind of thing worth sorting out before the person who holds that role goes on holiday. The app store connect user roles breakdown covers who can do what.

There is one documented way to move an identifier, and it is not deletion. Apple's Overview of app transfer says you can transfer an app while keeping it available for download, that the app retains its reviews and ratings, and that when an app is transferred it maintains its Bundle ID, which cannot be changed once a build has been uploaded for the app. After the transfer the associated App ID moves to the recipient's developer account, and a wildcard App ID is converted to an explicit App ID that exactly matches the bundle ID. The transfer criteria page requires at least one version released to the App Store, so an app that never shipped cannot be transferred either.

What is the Android equivalent, and are the rules the same?

The application ID, and on the question of changing it the two stores agree. Android's Configure the app module page says every Android app has a unique application ID that looks like a Java or Kotlin package name, and that this ID uniquely identifies your app on the device and in the Google Play Store. Its Important note reads: once you publish your app, you should never change the application ID, and if you change it the Google Play Store treats the upload as a completely different app. It also states that to upload a new version you must use the same application ID and signing certificate as when originally published. That page carried a last-updated date of 26 February 2026 when it was read on 21 October 2026.

Play Console Help puts the hard lock in the same place Apple does. On the page about setting up an open, closed or internal test, under the heading about testing apps that are not fully configured, Google says that once you upload an artifact, the package name for that app is fixed and cannot be changed. An internal testing upload counts. The second half of the Android rule is about the signing key rather than the name: because updates need the original signing certificate as well as the original application ID, losing the key costs you the app even though the identifier is intact. That is the subject of the google play app signing key guide, and it is the half people lose sleep over.

The character rules are where the two platforms quietly diverge. Android requires at least two segments, so one or more dots. Each segment must start with a letter. All characters must be alphanumeric or an underscore. Apple allows hyphens and periods and no underscores, and states that bundle IDs are case-insensitive. Android's naming rules on the page I read do not mention case at all. The practical upshot for anyone shipping both: a hyphen in your iOS bundle ID cannot be carried across, so pick a string of lowercase letters, digits and dots and use it twice.

One Android distinction has no Apple equivalent and causes real damage. The application ID and your code's package name are two different things. Android Studio sets applicationId from the package name you choose at setup, and the page says you can technically toggle the two independently from then on but recommends against it. It also recommends defining the application ID explicitly, because an undefined one inherits the namespace, which means a package refactor silently changes your store identity. Google adds that Context.getPackageName() returns your application ID rather than the code package, which is why so many Android APIs use the words package name for something else.

What happens to a package name when you delete a Play app?

It turns on installs, and the threshold is one. Play Console Help's Delete an app page has a section headed What happens to the package name with two lines in it. For a deleted app with zero lifetime installs, the package name will be freed up for reuse by anyone. For a deleted app with any lifetime installs, the package name cannot be reused by any other app, including apps created by the developer account that created the deleted app. A single tester who installed a single internal build is enough to retire that name permanently, for you as much as for anyone else.

Two Google pages disagree about this and it is worth knowing which one to follow. Create and set up your app says, under managing your app and app bundles, that package names for app files are unique and permanent, so please name them carefully, and that package names cannot be deleted or re-used in the future. No install condition, no exception. The Delete an app page carves out the zero-install case explicitly. The specific page beats the general one, but if you are planning around getting a name back, assume the stricter line and confirm with Google support rather than betting a launch on it. Both pages read on 21 October 2026, and neither prints a last-updated date.

Self-service deletion also has conditions that rule out most live apps. The app must be unpublished with any changes in review resolved. It must be installed on fewer than 1000 active devices, where an active device is defined as one that has been turned on at least once in the past 30 days. It must not be rejected, blocked or suspended. The feature excludes monetized apps, meaning paid apps or apps with in-app purchases or subscriptions, unless they have zero lifetime installs. Google says only the account owner can delete an app, and the requirements paragraph on the same page says you must be an admin of the developer account and provide the transaction ID, so confirm who holds what before you plan the work.

The mechanics are deliberately awkward, which is a mercy. You open Advanced settings under Test and release, find Delete app on the App availability tab, then type the app's package name and your developer account creation transaction ID to confirm. That transaction ID is the registration fee receipt, which Google tells you to find by searching the account owner's inbox for Developer registration fee. You then have seven days to recover the app before deletion is permanent, you lose access to all user data and metrics, and a deleted app cannot be transferred. If a transfer was ever on the table, do it first.

Google, Play Console Help, Delete an app, read 21 October 2026, no last-updated date printed