Android Package Name Generator
Enter your domain and app name — get a valid, Google-Play-ready package name (App ID) instantly. No signup needed.
Written by the Free App Maker team at My Mind Studio · Last verified 26 August 2026
com.yourdomain.yourapp. This free tool from Free App Maker turns your domain and app name into a valid one, checks it against Android's rules, and explains what you cannot change later.
Enter just the domain — no http:// needed. Examples: myshop.com, myapp.co, mybusiness.in
Your app's display name. Spaces and punctuation are automatically converted.
Package name rules
What makes a valid Android package name?
Android's build documentation gives exactly three naming rules for the application ID. Everything else on this page is convention, tooling, or Google Play policy — useful, but a different kind of rule, and worth telling apart.
"It must have at least two segments (one or more dots)." com.myapp.myshop has three, which is fine; myshop alone is not an application ID.
"Each segment must start with a letter." com.myapp.2shop is invalid; com.myapp.shop2 is valid. A leading underscore fails this rule too.
"All characters must be alphanumeric or an underscore [a-zA-Z0-9_]." So hyphens and spaces are out — and uppercase is technically allowed, though nobody uses it.
Not a rule, a naming habit borrowed from Java: com.yourdomain.appname. It gives global uniqueness without anyone running a registry.
Google Play Console calls package names "unique and permanent", and says they "can't be deleted or re-used in the future". This is the constraint that actually bites.
Android's three rules say nothing about length, and we found no documented limit. This tool flags anything over 100 characters as its own guardrail; most real IDs are 20–40.
Source: Android Developers — Configure the app module (Set the application ID), checked 26 Aug 2026.
Source: Play Console Help — Create and set up your app, checked 26 Aug 2026.
The distinction that trips people up
Package name vs. applicationId vs. namespace
Three names, one thing people assume they are. Ask "what is my app's package name?" and depending on which file you open you will get three different answers — and only one of them is the identifier Google Play cares about.
In a modern Gradle build, namespace is your Java or Kotlin package name: the folder structure your source lives in, and the base for your generated R class. applicationId is the identifier the outside world sees. They start life identical, because Gradle defaults one to the other, which is exactly why so many developers never notice they are separable.
Android's documentation is unambiguous about which one wins: "While the namespace property represents your app's Java or Kotlin package name, once the APK is compiled, the package attribute in the merged manifest file represents your app's universally unique application ID." And, more bluntly: "The merged manifest's package attribute is where the Google Play Store and the Android platform actually look to identify your app."
| Setting | What it actually is | Safe to change later? |
|---|---|---|
namespace | Your Java/Kotlin source package — folders and imports | Yes. Refactor it whenever you like; users never see it. |
applicationId | Your app's universally unique identifier | No, not once published. This is the permanent one. |
package in the merged manifest | Where the build copies your applicationId at the end of the build | Not set by hand in Gradle builds from AGP 7.3 onward. |
The practical upshot: the term "package name" survives in Android's own APIs for historical reasons. As the documentation puts it, "The application ID used to be directly tied to your code's package name, so some Android APIs use the term 'package name' in their method names and parameter names. This is actually your application ID." When a Play Console screen, a Firebase setup wizard or a payment SDK asks for your "package name", it wants your application ID.
Source: Android Developers — Configure the app module, checked 26 Aug 2026.
Where the old manifest rule still shows up
The manifest reference describes the same identifier from the other end: "The value of the package attribute in the APK's manifest file represents your app's universally unique application ID. It is formatted as a full Java-language-style package name for the Android app. The name can contain uppercase or lowercase letters, numbers, and underscores ('_'). However, individual package name parts can only start with letters."
It also spells out the consequence of getting cute with it after release: "Be careful not to change the package value, since that essentially creates a new app. Users of the previous version of your app don't receive an update and can't transfer their data between the old and new versions."
Source: Android Developers — <manifest> element reference, checked 26 Aug 2026.
The part you cannot undo
What happens if you get it wrong
Most decisions in an Android project are reversible. You can rename the app, redraw the icon, swap the entire codebase underneath it, change developer account details, even change the URL your app loads. The application ID is the one field where a bad choice follows you for the life of the product.
Android's guidance is a warning, not a suggestion: "Once you publish your app, you should never change the application ID. If you change the application ID, Google Play Store treats the upload as a completely different app. If you want to upload a new version of your app, you must use the same application ID and signing certificate as when originally published."
Concretely, here is what "a completely different app" means
- Nobody gets the update. Your existing users keep the old app. It does not notify them, it does not migrate them, it does not tell them a successor exists.
- Reviews and ratings stay behind. Rating history is attached to the listing, and the new identifier is a new listing starting from nothing.
- Install count resets. Whatever social proof and store-ranking signal you accumulated belongs to the old identifier.
- Two apps can sit on one phone. Because no two apps can share an application ID, the old and new versions install side by side rather than replacing each other — confusing for users who find both.
- Your old name is gone. You cannot free it up and start over, which is the trap the next section covers.
You cannot delete your way out of it
The obvious escape route — delete the app, republish under the name you meant to use — is closed by design. Play Console's publishing-issues page states plainly: "We're unable to delete apps or let multiple apps have the same package name."
Deletion has one narrow exception, and it turns on installs. Play Console documents that 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 can't be reused by any other app, including apps created by the developer account that created the deleted app".
Read that second clause twice. "Including apps created by the developer account that created the deleted app" means your own account gets no special privilege. One friend installing your test build is enough to burn the name permanently — so a throwaway identifier like com.test.app1 uploaded "just to see how Play Console works" is not as throwaway as it feels.
Sources: Android Developers — Configure the app module, Play Console Help — Publishing issues and Play Console Help — Delete an app, all checked 26 Aug 2026.
If you are heading toward a first release, it is worth reading our guide to publishing an Android app on Google Play before you create the Play Console entry, because creating the entry is the moment the identifier is claimed. Our write-up on why Google Play rejects apps covers the review problems that come after.
Why reverse-domain at all
The convention that replaced a registry
Every app on every Android device on earth needs a globally unique name, and no organisation hands them out. There is no central authority you apply to, no queue, no approval. The problem was solved by borrowing something that already had a unique-name system attached: the domain name system.
The habit comes straight from Java. Oracle's package-naming guidance says: "Companies use their reversed Internet domain name to begin their package names—for example, com.example.mypackage for a package named mypackage created by a programmer at example.com." Because you already have exclusive control of example.com, everything under com.example.* is implicitly yours, and nobody needs to arbitrate.
It is worth being precise about what this does and does not give you. Reverse-domain notation is a convention, not an enforcement mechanism. No part of the Android build checks whether you own the domain you used. What the convention buys you is coordination — and the ability to point at a WHOIS record if two apps ever collide or a dispute reaches a human.
That matters more than it sounds. Google Play's Impersonation policy states: "We don't allow apps that mislead users by impersonating someone else (for example, another developer, company, entity) or another app." The policy text addresses user-facing signals — developer names, titles, icons, descriptions — rather than the package name specifically, so borrowing a domain you do not own is not automatically a policy breach. It simply leaves you with no evidence and no argument if the real owner ever objects.
Sources: Oracle — Naming a Package (The Java Tutorials) and Play Console Help — Impersonation policy, checked 26 Aug 2026.
If you do not own a domain yet
Pick something you can still defend as yours and stay consistent — your registered business name reversed, or a namespace tied to an account you control. Avoid a generic com.app.myapp: it is the most likely string in the world to already be taken, and it tells a future reviewer nothing about who you are. A domain costs less than a takeaway coffee per month and settles the ownership question permanently, which is a reasonable trade for a decision you cannot revisit.
Edge cases
What people actually get wrong
Your domain is not always a legal package name
Reverse the domain mechanically and some domains produce something invalid. Oracle's guidance anticipates this: "This can occur if the domain name contains a hyphen or other special character, if the package name begins with a digit or other character that is illegal to use as the beginning of a Java name, or if the package name contains a reserved Java keyword, such as 'int'. In this event, the suggested convention is to add an underscore." Its examples: hyphenated-name.example.org → org.example.hyphenated_name; example.int → int_.example; 123name.example.com → com.example._123name.
A conflict worth knowing about. That last example is valid Java but is not a valid Android application ID: _123name starts with an underscore, and Android requires every segment to start with a letter. If your domain begins with a digit, lead the segment with a letter instead of an underscore.
Sources: Oracle — Naming a Package and Android Developers — Configure the app module, checked 26 Aug 2026.
Country-code domains give you a longer prefix
A .co.uk or .com.au domain reverses into three segments before you have named anything: uk.co.myshop, then your app segment on the end. That is perfectly valid — Android sets a minimum of two segments, not a maximum — it is just longer than the com.x.y shape most examples show. Some developers shorten it to uk.myshop.appname. Either works; pick one and never revisit it.
The word "test" in a name you later ship
An identifier chosen in five seconds becomes the one your users type into a support email two years later. com.test.app, com.example.myapp and com.mycompany.untitled all read as unfinished in Play Console, in crash reports, in deep links and in every third-party dashboard you connect. Because com.example is the documentation placeholder, it is also close to guaranteed to already be taken.
Suffixes are for build variants, not for versions
Android supports appending a segment per build variant through applicationIdSuffix, so a debug build can become com.example.myapp.debug. The documentation explains why: "This is useful when you want to have both the debug and the release build on the same device, because no two apps can have the same application ID." That is a legitimate use. Bumping the identifier for a new version of the same app is not — that is the mistake that turns an update into a second, unrelated listing.
Source: Android Developers — Configure build variants, checked 26 Aug 2026.
Renaming source folders is not renaming your app
Because namespace and applicationId are separate settings, a source-level refactor does not touch your published identity — and, conversely, a find-and-replace across your project can quietly change applicationId while you thought you were only tidying imports. Before any release, open your Gradle file and read the applicationId line with your own eyes.
Matching your ID to third-party services
Firebase projects, OAuth client IDs, push-notification configurations, deep-link verification files and analytics properties are all registered against the application ID. Change it and every one of those integrations stops recognising your app. This is usually how developers discover the ID matters — after something breaks, not before.
Step by step
How to choose a package name you will not regret
- Start from a domain you controlType the domain you own into the generator above. It reverses the parts, so
myshop.combecomescom.myshop. Reverse-domain notation is a convention rather than an enforced registry, so the domain is the evidence of ownership you fall back on if two apps ever collide. - Add a segment for this specific appType the app name. The generator appends it as a final segment, which is how one domain carries many apps:
com.myshop.storefrontandcom.myshop.bookingare two separate identifiers under the same namespace. - Check the result against Android's rulesConfirm every validation tag is green. Android requires at least two segments, every segment to start with a letter, and every character to be alphanumeric or an underscore. If a tag is red, edit your inputs or pick one of the suggested alternatives.
- Copy it and use the same identifier everywherePaste the result into the App ID / Package Name field in Free App Maker, or into
applicationIdin your Gradle build file. Use the identical string for every future release, because Google Play treats a changed application ID as a completely different app.
How this generator builds the name
No black box: everything runs in your browser and nothing is sent anywhere. The tool strips http://, https://, any path and a leading www., splits the domain on dots and reverses the order, then removes every character outside a–z and 0–9 from each segment and drops leading digits so no segment can start with a number. Your app name becomes the final segment. If that leaves fewer than two segments, it prefixes com. so the result is still valid.
That output is deliberately stricter than Android's rule. Android permits uppercase letters and underscores; this tool emits neither, because lowercase alphanumeric is the form every build file, tutorial and Play listing you will compare yours against actually uses. If you specifically want an underscore — the Oracle convention for a hyphenated domain, for instance — type the result into your Gradle file yourself.
Keep going
Related free tools and guides
Every tool below is free, runs in your browser, and needs no signup or email address. They pair naturally with picking an application ID — it is usually one item on a longer pre-launch list.
Once your identifier is settled, our website to APK converter builds the Android app itself: paste a URL, set the App ID you just generated, and get a signed APK. Building and previewing are free; downloading the signed APK is a one-time unlock, priced by country and always shown before checkout.
FAQ
Package name questions
com.myapp.myshop.namespace is your Java or Kotlin package name — the folders your source code lives in — while applicationId is the identifier the outside world sees. Android's documentation states that once the APK is compiled, the package attribute in the merged manifest file represents your app's universally unique application ID, and that the merged manifest's package attribute is where the Google Play Store and the Android platform actually look to identify your app. You can rename source packages freely; changing applicationId after release is what breaks things.com.myapp.myshopapp or com.myapp.shop2026 — using the alternatives this generator suggests, or by editing the output yourself.hyphenated-name.example.org becomes org.example.hyphenated_name, and example.int becomes int_.example because int is a reserved keyword. One trap: Oracle's fix for a domain starting with a digit is com.example._123name, but Android requires every segment to start with a letter, so a leading underscore is not a valid application ID segment — put a letter in front instead. This generator strips awkward characters rather than adding underscores, so read its output before you commit to it.Sources for the answers above: Android Developers — Configure the app module, Play Console Help — Create and set up your app, Play Console Help — Delete an app, Play Console Help — Publishing issues, Play Console Help — Impersonation and Oracle — Naming a Package. All checked 26 August 2026.
Got your package name? Build your app.
Paste your website URL into Free App Maker, set the App ID you just generated, and your Android app is built in about 60 seconds. Building and previewing are free; downloading the signed APK is a one-time unlock, priced by country and always shown before checkout.
Build your Android app — free to start →