Share via

How can I ask users for ratings and reviews in my Android game?

Kim Strasser 2,596 Reputation points
2026-06-02T15:33:39.7466667+00:00

I want that the prompt gets displayed in my game on Android devices after the user finished a level in my game. How can I display the prompt in my game and is it necessary that I check if the prompt was already displayed three times in a 365-day period like on iOS or is this different on Android? In addition, is it necessary to check if the user has already added a rating or a review?

Should I store the timestamp on a server when the prompt was displayed the last time in my game so that my game knows that the prompt doesn´t need to be displayed after each level in my game?

I only want to display the prompt in certain time intervals because I don´t want to display it too often. And it´s possible that the user plays my game on iOS and Android devices.

https://developer.android.com/guide/playcore/in-app-review?hl=en

Screenshot 2026-06-02 173657

Developer technologies | .NET | .NET Multi-platform App UI
0 comments No comments

2 answers

Sort by: Most helpful
  1. Nancy Vo (WICLOUD CORPORATION) 4,765 Reputation points Microsoft External Staff Moderator
    2026-06-03T04:37:56.2+00:00

    Hello @Kim Strasser ,

    Thanks for your question.

    Since you are building your game with .NET MAUI, Google's official In-App Review docs don't cover MAUI directly. Therefore, I recommend using the community-created Plugin.Maui.AppRating, which has gained over 57,000 downloads.

    For more information, you can refer to to this usage and code example.

    1. Install the nuget package
    dotnet add package Plugin.Maui.AppRating
    
    1. Register in MauiProgram.cs
    using Plugin.Maui.AppRating;
    
    public static class MauiProgram
    {
        public static MauiApp CreateMauiApp()
        {
            var builder = MauiApp.CreateBuilder();
            builder
                .UseMauiApp<App>()
                .ConfigureFonts(fonts =>
                {
                    fonts.AddFont("OpenSans-Regular.ttf", "OpenSansRegular");
                    fonts.AddFont("OpenSans-Semibold.ttf", "OpenSansSemibold");
                });
    
            builder.Services.AddTransient<MainPage>();
    
            builder.Services.AddSingleton<IAppRating>(AppRating.Default);
    
            return builder.Build();
        }
    }
    
    1. Code example in your game page
    using Plugin.Maui.AppRating;
    
    public partial class GamePage : ContentPage
    {
        private readonly IAppRating _appRating;
    
        private const string AndroidPackageName = "com.yourcompany.yourgame";
        private const string IOSApplicationId   = "idYOURAPPID";
    
        public GamePage(IAppRating appRating)
        {
            InitializeComponent();
            _appRating = appRating;
    
            _appRating.ThrowErrors = false;
        }
    
        public async Task OnLevelCompleted()
        {
            int levelsCompleted = Preferences.Get("levels_completed", 0) + 1;
            Preferences.Set("levels_completed", levelsCompleted);
    
            if (levelsCompleted % 5 == 0)
            {
                await CheckAndShowReviewPrompt();
            }
        }
    
        private async Task CheckAndShowReviewPrompt()
        {
            if (Preferences.Get("app_rated", false))
                return;
    
            var lastShownStr = Preferences.Get("last_review_shown", string.Empty);
            if (!string.IsNullOrEmpty(lastShownStr))
            {
                var lastShown = DateTime.Parse(lastShownStr);
                var daysPassed = (DateTime.UtcNow - lastShown).TotalDays;
    
                if (daysPassed < 30)
                    return;
            }
    
            await MainThread.InvokeOnMainThreadAsync(async () =>
            {
                bool wantsToRate = await DisplayAlert(
                    "Enjoying the game? ",
                    "Would you like to leave a quick review? It really helps us!",
                    "Sure!", "Maybe later"
                );
    
                if (!wantsToRate)
                {
                    Preferences.Set("levels_completed", 0);
                    return;
                }
    
                await ShowNativeReviewPopup();
            });
        }
    
        private async Task ShowNativeReviewPopup()
        {
            await MainThread.InvokeOnMainThreadAsync(async () =>
            {
    #if DEBUG
                await _appRating.PerformInAppRateAsync(isTestOrDebugMode: true);
    #else
                await _appRating.PerformInAppRateAsync();
    #endif
            });
    
            Preferences.Set("last_review_shown", DateTime.UtcNow.ToString());
    
            Preferences.Set("app_rated", true);
        }
    
        private async void OnRateUsButtonClicked(object sender, EventArgs e)
        {
            if (Preferences.Get("app_rated", false))
                return;
    
            await MainThread.InvokeOnMainThreadAsync(async () =>
            {
                try
                {
                    await _appRating.PerformRatingOnStoreAsync(
                        packageName:   AndroidPackageName,
                        applicationId: IOSApplicationId
                    );
                }
                catch (Exception ex)
                {
                    System.Diagnostics.Debug.WriteLine($"Rating error: {ex.Message}");
                }
            });
    
            Preferences.Set("app_rated", true);
        }
    }
    

    How can I display the prompt in my game after finishing a level?

    When the player finishes a level, you call OnLevelCompleted(). The code above then:

    • Counts how many levels they've completed (stored locally on device)
    • Only considers showing the prompt every 5 levels
    • Checks your own timing rules (30-day interval)
    • Then calls PerformInAppRateAsync() which shows the native Google Play popup right inside your game - the player never leaves your app.

    Is it necessary that I check if the prompt was already displayed three times in a 365-day period like on iOS or is this different on Android

    On Android, you do not need to check or count how many times the popup has been shown. Google enforces a quota automatically and secretly. Here's what Google officially says:

    "Google Play enforces a time-bound quota on how often a user can be shown the review dialog. The specific value of the quota is an implementation detail and it can be changed by Google Play without any notice."

    Is it necessary to check if the user has already added a rating or a review?

    No, and it is actually impossible to check this. Neither Google nor Apple tells your app whether the user actually submitted a rating. This is intentional to protect user privacy.

    Should I store timestamps on a server?

    If your player has an account and plays on their Android phone and their iPad, the two devices don't know about each other's local storage. In that case, I recommend storing the last_review_shown timestamp on your server tied to the user's account. But honestly, even in this case - both Google and Apple already silently limit how often the native popup actually appears, so the real-world impact is low.

    Note:

    • Do not run the app in debug mode
    • Run on real devices

    While these links are non-Microsoft links, they are official Github, Nuget and Android documentations and are safe to visit.

    I hope this addresses your question. If this response was helpful, please consider following the guidance to provide feedback.

    Was this answer helpful?


  2. AI answer

    2026-06-02T15:34:08.4666667+00:00

    Use an in-app rating/review prompt that is triggered at appropriate moments in the game, such as after the player finishes a level or reaches another meaningful milestone. This aligns with guidance for Microsoft Store apps, where in-app prompts are recommended to collect representative feedback and improve ratings.

    The key points for designing the logic are:

    1. Trigger after positive milestones
      Display the prompt after events like:
      • Completing a level or major task.
      • Using a valuable feature.
      • After a major update or special event.
      This avoids interrupting gameplay flow and reaches players when they are more likely to respond positively.
    2. Avoid showing the prompt too often
      The guidance explicitly recommends avoiding repeated requests, as users may get frustrated and leave negative reviews.
      To achieve this:
      • Maintain a counter and/or timestamp for when the prompt was last shown.
      • Only show the prompt again after a certain number of levels or a minimum time interval.
    3. Cross-device considerations
      Since players may use both iOS and Android, storing prompt metadata (such as last-shown timestamp and count) on a backend is a reasonable approach. This lets the game avoid prompting too frequently across platforms.
    4. Platform-specific limits
      The provided context does not define platform-specific numeric limits (such as “three times in 365 days”) for Android, nor does it require checking whether the user has already rated. Instead, it focuses on:
      • Using the platform’s in-app rating API.
      • Strategically timing prompts.
      • Avoiding repeated prompts.
      Implement platform-specific limits and checks according to each store’s official in-app review API documentation, but always layer on the app’s own throttling logic to avoid over-prompting.
    5. Implementation outline
      • Integrate the platform’s in-app rating/review API in the game.
      • After a level completion, evaluate:
        • Has the prompt been shown recently (based on stored timestamp/interval)?
        • Has it exceeded a maximum count within a chosen period (app-defined)?
      • If conditions are met, call the in-app rating API.
      • Record the time and increment the count (locally and optionally on a server for cross-device sync).

    This approach ensures prompts are shown at good moments, not too frequently, and can be coordinated across Android and iOS while respecting each platform’s own rules.


    References:

    AI-generated content may be incorrect. Read our transparency notes for more information.

    Was this answer helpful?

Your answer

Answers can be marked as 'Accepted' by the question author and 'Recommended' by moderators, which helps users know the answer solved the author's problem.