Blog / Build with AI /

Chrome Web Store rejections: the common reasons

You’ve built your extension. It works. You upload it, fill in the form, press submit and wait. Then the email arrives: “Your item was not published.”

A rejection stings, mostly because the message can be vague and the fix isn’t always obvious. The good news is that most rejections come from a short list of causes, and nearly all of them are avoidable if you check before you submit.

This post covers those common causes in plain words. I can’t give you inside knowledge of how reviewers think, and the policies are updated from time to time, so treat Google’s current developer policies as the final word. What follows are the recurring themes.

If you haven’t read it, publishing to the Chrome Web Store: what the review process is like covers the process from submission to approval.

1. Permissions that go beyond what the extension does

This is the most common theme. Every permission you request in manifest.json should be necessary for a feature you can name.

Typical problems:

  • Asking for access to all websites when the extension only works on one or two.
  • Requesting permissions “just in case” for later features.
  • Leaving permissions in the manifest after removing the feature that needed them.

The principle is least privilege: ask for the minimum. If your extension only reads the current tab when the user clicks it, you may not need broad host access at all. Ask your AI assistant to review the manifest:

Here is my manifest.json and a description of what the extension does. For each permission, tell me which feature uses it, and flag any that look unnecessary or narrower alternatives that would work.

Then verify its claims yourself against the documentation, since it can be wrong about what a permission actually allows.

Also be ready to explain each permission. The store listing process asks you to justify them, and your answers should match the code.

2. A single purpose that is unclear

Chrome expects an extension to have one narrow, easy-to-understand purpose. A tool that organises tabs, blocks ads, changes new tab pages and shows weather is hard to describe, and tends to draw attention.

If your description needs three “and”s, consider splitting it into separate extensions. It also helps users. I made a similar point in building one feature well vs ten features badly.

3. Missing or inadequate privacy policy

If your extension handles user data, you need a privacy policy, and it must be accurate. “User data” is wider than people expect. It can include browsing activity, page content, form entries, and even sometimes the list of open tabs.

Common failures:

  • No policy link at all.
  • A policy that doesn’t mention what the extension actually collects.
  • A policy that says “we collect nothing” when the code sends data to a server.
  • A dashboard disclosure that contradicts the policy.

If your extension keeps everything on the user’s device, say so plainly, and mean it. Make the disclosure form, the policy, and the code agree with each other. Privacy-first tools: keeping user data local explains that approach.

4. Remote code

Chrome’s current extension platform (Manifest V3) doesn’t allow extensions to run code that is fetched from elsewhere. All logic should ship inside the package you upload.

Warning signs:

  • Loading a script from a CDN link and running it.
  • Using eval or building functions from strings.
  • Pulling instructions from a server that change how the extension behaves.

AI-generated code sometimes does this, because many web examples load libraries from a CDN. Bundle libraries into the extension instead. Fetching data from an API is generally fine; fetching code to execute is not.

5. Misleading or spammy listing

The store listing is reviewed too, not just the code. Problems include:

  • Keyword stuffing: a description that repeats search terms in a long list.
  • Claims the extension doesn’t deliver, such as “works on every website” or “100% secure”.
  • Screenshots that don’t match the real interface.
  • Using another brand’s name or logo in a way that implies a connection.
  • Fake or incentivised reviews.
  • A title that has extra terms rather than a name.

Write the listing like you’d explain the tool to a friend. Say what it does, and what it doesn’t. Use real screenshots, with a short caption.

6. It doesn’t work, or breaks on review

Reviewers install the extension and try it. If it crashes, shows an empty popup, needs an account they don’t have or is missing a feature the listing promises, expect a rejection.

Before submitting:

  • Install the packaged zip in a clean browser profile, not the folder you’ve been developing in.
  • Run through every feature as a first-time user would.
  • If sign-in is needed, provide test credentials in the review notes.
  • Check the console for errors. Debugging a Chrome extension: the tools that help covers where to look.
  • Make sure it works with a fresh install and also after an update.

7. Handling data in ways users wouldn’t expect

Any behaviour that surprises users is risky. Examples that the policies treat seriously:

  • Collecting browsing history or page content without a clear need or disclosure.
  • Sending data to third parties without saying so.
  • Injecting ads or changing search results or affiliate links without clear user benefit and disclosure.
  • Using collected data for purposes unrelated to the extension’s function.

If you monetise, be transparent about how. Making money from a Chrome extension: the options discusses the routes and their trade-offs.

8. Poor-quality or repetitive submissions

Submitting many near-identical extensions, or a minimal “wrapper” that adds nothing, can run into spam policies. One well-made, clearly useful extension beats five thin copies.

Pre-submission checklist

If you’re rejected

  1. Read the message carefully. It usually names the policy involved.
  2. Don’t just resubmit. Fix the specific issue, and check for related ones.
  3. Reply with clarity if the message was wrong or unclear, using the developer support routes the store provides.
  4. Keep a log of what was flagged and what you changed. It also helps to keep notes in your build log.
  5. Be patient. Reviews can take days, and repeated rapid resubmissions don’t speed things up.

Key takeaways

  • Most rejections trace to permissions, purpose, privacy policy, remote code or the listing.
  • Ask for the least access that works, and justify every permission.
  • Make your disclosures, policy and code tell the same story.
  • Bundle all code; don’t execute fetched code.
  • Test the packaged build as a stranger would.

Open your manifest right now and read each permission aloud. Can you point to the feature that needs it?