How to hack your app store ratings

One of the biggest things affecting conversion is your app’s App Store or Google Play Store rating. Many users see a good rating as a sign of trustworthiness, feature richness, and value. But that doesn’t mean good apps automatically have a good rating. 

The layman psychology behind app store ratings is that people are far more likely to publicly complain if something is wrong, than go out of their way to publicly praise something. Even for popular apps, negative reviews dominate over positive. Capturing those good reviews is crucial to unlock growth.

One approach is by ethically hacking the system by building a ‘rating happiness engine‘ that will prompt users to rate your app at the time they are most satisfied with it. First, let’s go through how app store ratings work, their benefits for user acquisition, and learn why good apps don’t necessarily have good ratings.

Note: When we say “app store”, we’re generalizing across the Apple App Store and Google Play Store, as well as other Android app distribution platforms like the Huawei App Gallery and Amazon Appstore. The ratings and reviews work in similar fashion across all of these. 

Ratings and reviews

App stores use a combination of numerical ratings and qualitative reviews to provide users feedback on the value and user satisfaction of apps. 

From a growth perspective, ratings and reviews are critical. As explained in our App store optimization guide, ratings have a compounding effect: higher ratings improve conversion, which boosts organic visibility, drives more downloads, and generates more reviews.   

How app ratings works

There are two qualities to app store ratings:

• Average rating: an average of the ratings the app has received from users
• Rating count: how many ratings the app has

Users rely on both metrics to evaluate the app’s perceived value: average rating tells a customer satisfaction story, and the number of ratings provides validity to that number. 

Users can rate the app either in app stores or directly in the app. Apple gives a simple average of all ratings the app has received, while Google shows a weighted average placing heavier emphasis on more recent reviews. Both stores show the average rating in the app’s product page and search results. Apps with more reviews and higher average rating also rank higher in the app store’s search results.

Users can rate your app on a scale of one to five. Individual ratings shape your app’s summary rating, which the product page and search results then display. This summary rating is specific to each territory on the App Store and you can reset it when you release a new version of your app.

When should I reset my app’s ratings?

Only Apple allows developers to reset the ratings on their app, which you might consider if your app has been in the app store for years and has recently gone through a revamp, which would justify shaking off the baggage of old 1 star reviews. Google doesn’t allow developers to reset their ratings. Resetting ratings also doesn’t remove reviews, just the numerical rating.

If your app has an average rating from thousands of reviews it’s preferable to keep them, as building that amount of reviews will take time—and even if you reset the rating number, the reviews will still speak volumes. Users can change their rating, so developers often achieve better results by improving the app and prompting users to rate it again, rather than resetting ratings.

How app reviews work

Similar to ratings, reviews are another factor that encourages users to evaluate if the app is worth downloading. Reviews that mention bugs, features, and pricing are what users often look at most often before downloading the app. The same as ratings, users can review apps in the app store itself, or directly in the app.

The best way to turn bad user reviews into good user reviews is to answer all of the feedback users submit to app stores. For example, telling users that a bug they encountered has been fixed, a new feature has been released, or pricing has been adjusted. You can do this in the developer response section of the review, and it will often lead to previously-negative reviews turning positive. Users feel they they are being heard. Reviews with developer response are also shown in the app’s product page before the ones without, so it’s an ideal way of showing that you value user feedback.

Starting this year, Apple began using an LLM (large-language-model) system to generate short summaries of App Store reviews, distilling thousands of user comments into concise highlights that surface the main themes of feedback. These AI-driven summaries help users quickly understand sentiment, but they don’t replace the importance of star ratings. Ratings remain the most visible trust signal in search results and product pages.

Hacking app store ratings

The simplest hack for improving your ratings is to get users that are satisfied with your app to rate the app, and redirect the unsatisfied ones to give their feedback through another channel that you control. 

So, how do you tell these two types of users apart? Ask them.

This can be done as easily as an in-app notification that says “Are you enjoying [app name]?”, with simple yes and no answers. Answering ‘no’ will prompt the user to leave feedback through a custom form or similar, and answering ‘yes’ will ask the user if they want to leave review. This way, you still gather constructive critiques, and can address this, but you can also prioritize positive feedback showing on the app stores.

This hack works great for filtering satisfied and unsatisfied users, but it doesn’t solve how we capture the satisfied users. Let’s consider a more systematic approach.

Taking things further – building the customer satisfaction engine

We could of course prompt the modal every so often, but that would quickly frustrate users. Instead, we can be more systematic and focus on capturing users in the right moment.

By building a customer satisfaction engine, you can monitor user interactions over time and decide when the positive occurs. One way to do this is assigning a score to key user actions, for example:

• Opening the app (1 point)
• Using a key feature (10 points)
• Subscribing (10 points)

When the cumulative score passes a threshold (e.g. 15 points), you can make the assumption that the user is enjoying using the app. This means prompting them now is likely to lead to a good review.

This approach aligns well with both Google Play’s in-app review guidelines, which recommend requesting reviews only after “meaningful user actions”, and Apple’s Human Interface Guidelines, which emphasize asking for reviews at “natural and happy moments.” This is the best principle for avoiding annoying your users.

One more thing we should add in our happiness calculation is a method for decaying happiness events. One example might be if “app open” gives you 1 point, then that 1 point decays completely in one day. Opening the app multiple times a day increases the counter, but rarely opening the app does not count as engagement.

Building the happiness engine with code

Three simple ideas form the foundation of the happiness engine.

1. Record meaningful actions as “events”: these are the things that usually signal user satisfaction—finishing a workout, subscribing, or completing a purchase. You decide which actions matter and how valuable each should be.
2. Calculate a score that decays over time: each action gives points, but those points fade with time (exponential decay). That means frequent, recent engagement drives the score up, while old activity slowly stops mattering.
3. Show the review prompt at the right time: when the score passes a threshold and a cooldown period has passed since the last prompt, try showing the in-app review dialog.

The first step to building the engine is listing our events that we want to capture happiness points for.

1const config = {
2  actionConfigs: {
3    app_open: { basePoints: 1, halfLifeInDays: 1 },
4    use_feature_x: { basePoints: 5, halfLifeInDays: 2 },
5    subscribe_pro: { basePoints: 10, halfLifeInDays: 14 },
6  },
7  scoreThreshold: 16,
8};
9

The engine itself will use these to keep track of the score and prompt the user to review once the score goes over the threshold:

1type UserAction = 'app_open' | 'use_feature_x' | 'subscribe_pro';
2
3type ActionConfig = {
4  basePoints: number;
5  halfLifeInDays: number; // how fast the points decay
6};
7
8type Config = {
9  actionConfigs: Record<UserAction, ActionConfig>;
10  scoreThreshold: number;
11  promptCooldownInHours: number;
12  pruneAfterDays: number;
13};
14
15type Event = { action: UserAction; timestamp: number };
16
17class HappinessEngine {
18  private events: Event[] = [];
19  private lastPrompt: number = 0;
20
21  constructor(private config: Config) {}
22
23  // Record a new action
24  record(action: UserAction) {
25    this.events.push({ action, timestamp: Date.now() });
26  }
27
28  // Calculate the current happiness score
29  private calculateScore(): number {
30    const now = Date.now();
31    let score = 0;
32
33    for (const e of this.events) {
34      const { basePoints, halfLifeInDays } = this.config.actionConfigs[e.action];
35      const ageInDays = (now - e.timestamp) / (1000 * 60 * 60 * 24);
36
37      // exponential decay: each half-life cuts the value in half
38      const decay = Math.pow(0.5, ageInDays / halfLifeInDays);
39      score += basePoints * decay;
40    }
41    return score;
42  }
43
44  // Decide if we should show the prompt
45  shouldShowPrompt(): boolean {
46    const score = this.calculateScore();
47    const cooldownPassed =
48      Date.now() - this.lastPrompt >= this.config.promptCooldownInHours * 3600 * 1000;
49
50    return score >= this.config.scoreThreshold && cooldownPassed;
51  }
52
53  // Try showing a prompt
54  maybeShowPrompt(): boolean {
55    if (!this.shouldShowPrompt()) return false;
56
57    console.log('👉 Showing review prompt…');
58    this.lastPrompt = Date.now();
59    return true;
60  }
61}
62
63// Example usage
64const engine = new HappinessEngine({
65  actionConfigs: {
66    app_open: { basePoints: 1, halfLifeInDays: 1 },
67    use_feature_x: { basePoints: 5, halfLifeInDays: 2 },
68    subscribe_pro: { basePoints: 10, halfLifeInDays: 14 },
69  },
70  scoreThreshold: 16,
71  promptCooldownInHours: 336, // 14 days
72  pruneAfterDays: 120,
73});
74
75engine.record('app_open');
76engine.record('use_feature_x');
77
78if (engine.maybeShowPrompt()) {
79  // In a real app: call the iOS or Android in-app review API here
80}
81

How this works:

• App open (1 point, fades in 1 day): Opening the app is a weak signal, but repeated openings in a short time show engagement
• Using a key feature (5 points, fades in 2 days): Stronger proof that the user finds real value, so it counts more and decays more slowly
• Subscribing to Pro (10 points, fades in 14 days): A clear sign of commitment and satisfaction, so it gives the highest points and stays relevant for weeks
• Score threshold (16 points): Prevents a single action from triggering a prompt—the user needs a combination, e.g., multiple app opens + a feature use, or a subscription + some activity

React Native example

At this point, we’ve covered the theory, the psychology behind ratings, and even walked through code you can adapt for your own app. But reading code in an article isn’t the same as actually experimenting with it. That’s why I built a small demo app where you can play around with the happiness engine yourself.

In the demo, you can click buttons to simulate actions like “use feature X,” or “subscribe to Pro.” Each event adds points that decay over time. Once the score passes the threshold, the engine tries to show the in-app review prompt. This makes it easy to see how different behaviors stack up and when the prompt would actually fire.

Ready to give it a go?

App store ratings are one of the strongest levers you have for growth. They affect how many people trust your app, whether you rank higher in searches, and ultimately how many new users you win. The tricky part is that ratings don’t always reflect how good your app really is. Unhappy users are often more vocal than happy ones.

That’s why it’s so important to deliberately capture the moments when your users are most satisfied. By listening to feedback, responding to reviews, and prompting people at the right time, you can tilt the balance in your favor. The goal isn’t to trick the system, but to give your happiest customers the nudge they need to share their experience publicly.

Do this well, and you’ll create a cycle: higher ratings lead to more downloads, which lead to more happy users, which lead to even higher ratings. In the long run, that steady compounding effect is one of the most powerful growth hacks you can put in place.