How to request ratings for your Flutter app with in_app_review

One of the factors that most influences a mobile app’s success is its store rating. An app with an average rating of 4.8 stars inspires far more trust than one with 3.7, which can translate into more downloads and better conversion rates.

However, many developers expect users to voluntarily open Google Play or the App Store to leave a review. In practice, this rarely happens.

Flutter offers a simple solution through the in_app_review package, which lets you request the rating directly from within the app, without the user having to leave the experience.

What is in_app_review?

in_app_review is an official Flutter package that uses each platform’s native APIs:

• Google Play In-App Review API on Android.
• SKStoreReviewController on iOS.

When the conditions set by each platform are met, a small dialog is shown so the user can rate the app without opening the store.

Advantages of using in_app_review

Its main benefits include:

• Increases the number of ratings received.
• Improves the app’s average rating.
• The user doesn’t need to leave the app.
• Integration is very simple.
• Works on both Android and iOS.
• Uses the official Google and Apple APIs.

Installation

Add the dependency to pubspec.yaml:

dependencies:
  flutter:
    sdk: flutter

  in_app_review: ^2.0.10

Then run:

flutter pub get

Import the package:

import 'package:in_app_review/in_app_review.dart';

Centralizing the functionality

A good practice is to encapsulate all the logic in a utility class. That way, any screen in the app can request the rating with a single call.

import 'package:in_app_review/in_app_review.dart';

class Util {

  static final Util _instance = Util._init();

  factory Util() => _instance;

  Util._init();

  Future<void> showValorateApp({bool forceStore = false}) async {

    final available = await InAppReview.instance.isAvailable();

    if (available && !forceStore) {
      await InAppReview.instance.requestReview();
    } else {
      await InAppReview.instance.openStoreListing();
    }
  }
}

This implementation has several advantages:

• All the logic is centralized in a single place.
• The rest of the app doesn’t need to know how in_app_review works.
• If the implementation changes in the future, only this class needs to be modified.

How does it work?

The showValorateApp() method follows very simple logic:

1. It checks whether In-App Reviews are available on the device.
2. If they are, it requests the rating inside the app.
3. If they aren’t, or if forceStore = true is passed, it opens the app’s store listing directly.

This ensures the user always has an alternative.

Using the class

From anywhere in the app, simply call:

await Util().showValorateApp();

In this case, the app will try to show the built-in rating dialog.

If you want to open the app’s page on Google Play or the App Store directly — for example from a “Rate app” button — just use:

await Util().showValorateApp(forceStore: true);

When should you request a rating?

Choosing the right moment matters far more than the technical implementation.

Some good scenarios:

• After generating a new CV.
• After successfully finishing a simulation.
• After exporting a document.
• After completing a purchase.
• When the user reaches an important goal inside the app.

At these moments the user has just received a benefit and is much more likely to leave a positive rating.

When should you NOT request it?

Avoid showing the request:

• On the app’s first launch.
• During the sign-up process.
• While the user is in the middle of an important task.
• Right after showing an error.
• Repeatedly on every app start.

Requesting a rating at the wrong time usually produces the opposite of the desired effect.

Important considerations

It’s important to understand that running:

await InAppReview.instance.requestReview();

does not guarantee the rating dialog will be shown.

The final decision belongs to Google Play and the App Store, which weigh several internal factors, including:

• How many times the rating has already been requested.
• How frequently the app is used.
• Time elapsed since the last request.
• Each platform’s internal policies.

That’s why it’s completely normal for the dialog not to appear every time during testing.

Best practices

A recommended strategy is to combine in_app_review with some form of local persistence — for example shared_preferences — to track when a rating was last requested.

Common strategies include:

• Requesting it only after the user has used the app several times.
• Showing it after completing an important action.
• Waiting several months before requesting it again.

Although Google and Apple already limit the frequency automatically, controlling this behavior from the app as well improves the user experience.

Conclusion

The in_app_review package lets you integrate, in just a few minutes, a feature that can have a significant impact on your app’s reputation in the stores.

The implementation is simple, but real success depends on requesting the rating at the right moment. Showing the dialog after the user completes a satisfying action — and avoiding being pushy about it — considerably increases the chances of getting positive reviews and improving your app’s visibility on Google Play and the App Store.