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

Most of us know the feeling of typing a name into the app name field and finding that the Save button works. As an indie developer, I get a small sense of relief at that moment every time I ship something new.

It is worth asking what that relief is actually vouching for. What the store checks is whether the name collides with another name inside that same store. Whether you may use the name out in the world is a different question, answered by a different system.

Below I write down what I look at before choosing a name, and how I separate "what the store carries over" from "what I have to fix by hand" when a name changes after release. I can't give legal judgments, so I draw a line there and leave that part to professionals and public offices.

"I got the name" and "I may use the name" are different things

Apple's App Store Connect help says an app name must be at least 2 and no more than 30 characters. App Review Guideline 2.3.7 asks for a unique name, a limit of 30 characters, and no stuffing of metadata with trademarked terms.

What I read from that is that the store asks for uniqueness and for staying inside its rules. The Save button does not promise that your name is clear of someone else's trademark rights.

I remember it this way: the store lends you a place to put a name; it does not decide who owns the name. Ownership belongs to trademark law, which is a separate system.

Three places to look before you decide

I go from the cheapest check to the more tedious ones.

Save a screenshot of the first result. Later you can explain to yourself what you looked at when you decided.

Judging whether two marks are similar becomes specialist work quickly. For a name you are unsure about, a patent attorney or the JPO's consultation desk is the sure route. I am not an expert, so the decision from here is yours.

What the documentation says about renaming after release

Reasons to rename after release go beyond a trademark objection: an ASO rethink, or the app's role growing. Here is only what the official pages let me say.

Because the identifiers stay the same, my understanding is that the store treats it as the same app with a different name. The pages I checked did not say how ratings and reviews are handled, so please confirm that in your store's help before you rename.

What the store won't carry for you, you gather yourself

The costly part of a rename is not the store screen. It is the old name scattered inside the app and outside it.

• The name shown on the home screen (the name in Expo's app.json)
• Settings screens and "About this app" text
• The privacy policy and terms of use
• Text inside screenshots
• Your support page, website, and social profiles

Whatever lives inside the project can be found by machine. This is the short script I use.

# find_old_name.py — list where the old app name still appears in a project
import sys
from pathlib import Path
 
# Folders to skip (dependencies and build output)
SKIP_DIRS = {"node_modules", ".git", "Pods", "build", ".expo", "dist"}
# Only read text-like files; skip images and other binaries
TEXT_SUFFIXES = {".json", ".js", ".ts", ".tsx", ".md", ".mdx", ".plist",
                 ".xml", ".strings", ".swift", ".kt", ".html", ".txt"}
 
def scan(root: Path, old_name: str) -> int:
    hits = 0
    for path in root.rglob("*"):
        if any(part in SKIP_DIRS for part in path.parts):
            continue
        if not path.is_file() or path.suffix not in TEXT_SUFFIXES:
            continue
        try:
            lines = path.read_text(encoding="utf-8").splitlines()
        except UnicodeDecodeError:
            continue  # skip files in a different encoding
        for no, line in enumerate(lines, 1):
            if old_name in line:
                hits += 1
                print(f"{path.relative_to(root)}:{no}: {line.strip()[:80]}")
    return hits
 
if __name__ == "__main__":
    root, old = Path(sys.argv[1]), sys.argv[2]
    total = scan(root, old)
    print(f"-- {total} hits")

Run it as python3 find_old_name.py ./my-app "Old Name". It will not catch spellings that differ in case or width, so run it once per spelling of the old name.

I use a script because "whoever notices fixes it" always leaves something behind. A single line of the old name tucked into a settings screen is usually something you only learn about after release, when a user points it out.

The line I draw before a rename

Everything above boils down to one sentence for me.

I decide on a name only after looking at a trademark search result once. Being able to save it in the store is no substitute.

Renaming after release is not a matter of fixing one name. It means walking through every place the old name was left, inside and outside the app. A few minutes of checking at the start can sometimes spare you that work entirely.

If you are already at the stage of fitting names to each language, I wrote about handling names and subtitles in "How to Build ASO for 16 Languages".

For now, I'd suggest typing the name you currently use for your app into the J-PlatPat trademark search and saving one screenshot of the result. If nothing comes up, that is reassurance; if something does, considering a rename early is far lighter than doing it later.