Guide · 8 min read
SKStoreReviewRequest Implementation 2026: Use All 3 Prompts When They Actually Count
Apple caps the iOS review prompt at three displays per device per 365 days. That limit resets by device, enforces silently, and gives your app no feedback about whether a user rated. Most apps burn at least one of their three shots on a user mid-task, before any value has been delivered — the prompt fires, gets dismissed, and disappears permanently. Here's the implementation pattern that queues each prompt for the moment of maximum user satisfaction, and what to do when all three have been spent.
SKStoreReviewRequest: 3 prompts per 365 days, silently enforced
Apple's review prompt API — commonly called SKStoreReviewRequest, though the actual 2026 class is AppStore.requestReview(in:) imported from StoreKit, or the SwiftUI requestReview environment action — allows exactly three prompt displays per device per rolling 365-day window. The period is not a calendar year. It runs from the date of the first prompt display on that device, resetting exactly 365 days later. If a user first sees the prompt in March, the window resets in March of the following year — not January, not the app's install anniversary.
The enforcement is silent: when the cap is exhausted, the API call does nothing. No error is thrown, no callback fires, the user sees nothing, and there is no way to query whether the cap has been reached from within the app. This is intentional design — Apple prioritizes user experience over developer observability. The practical consequence: an app that calls the API carelessly on every fifth session will exhaust its annual budget on early-session users who haven't experienced the product, then fire into silence for every high-satisfaction user who follows.
The most common waste pattern is a session-count trigger: 'show review prompt after the fifth session.' Session five sounds reasonable, but it doesn't distinguish between a user who has completed a meaningful task and a user who opened the app five times without doing anything substantive. Five quick launches from an unconvinced user consumes one of three annual prompts on exactly the user least likely to leave a positive review. The session-count heuristic exists because it's easy to implement — not because it converts well.
The current API in 2026: deprecation, SwiftUI, and UIKit paths
As of iOS 18, Apple deprecated SKStoreReviewController.requestReview(in:) — the UIKit scene-based method that most tutorials still teach. The replacement for UIScene-based apps is AppStore.requestReview(in:), available from iOS 16, imported from StoreKit 2. For SwiftUI apps, Apple's preferred path since iOS 16 is the @Environment(\.requestReview) property wrapper: declare @Environment(\.requestReview) private var requestReview in your view struct, then call requestReview() at the right moment. Both APIs carry the same cap — 3 prompts per 365 days — with identical silent enforcement.
For UIKit, the minimum correct implementation calls Task { await AppStore.requestReview(in: windowScene) } where windowScene is retrieved from UIApplication.shared.connectedScenes. The critical constraint: never trigger the prompt inside a button's action handler. Apple's guidelines explicitly prohibit placing the review prompt in direct response to a user action. The trigger must come from your own business logic — a completed workout, a finished task, a successful export — not from a UI interaction the user expects to produce some other result. Calls placed on button taps risk App Store review rejection.
For SwiftUI, the implementation is two lines: the @Environment property at the top of your view struct, and requestReview() wherever your business logic determines the moment is right — typically inside a .onChange modifier watching a completed-task flag, or in an async task following a successful user action. Leave a 1–2 second async delay after the completion event so the prompt doesn't interrupt the success animation. The environment approach also makes the trigger trivially testable: replace the environment value in previews and unit tests without any real system calls.
When to trigger: moments of maximum satisfaction, not session milestones
The correct trigger for a review prompt is the moment after a user completes something that proves the app delivered its core promise. This moment is category-specific, but the structure is identical: completion of a meaningful unit of value. A fitness tracker should trigger after a workout is logged — not after the user opens the app for the fifth time. A writing app should trigger after the user exports or shares a document — not after three sessions. The difference in conversion between a satisfaction-triggered prompt and a session-triggered prompt is typically 2–3×, based on consistent patterns observed across ASO audit data. For a broader view of how timing strategy affects rating volume at scale, the review prompt timing guide covers the full research on when prompts convert best by category.
Specific trigger patterns by category: for fitness and habit apps, trigger after completing a streak milestone (day 7, day 30) or after the first workout logged in a new week — moments where the user has experienced success, not just effort. For productivity and task-management apps, trigger after the user marks a task complete, particularly when it's the last item in a list — completion dopamine peaks exactly there. For utility apps (file converters, PDF tools, calculators), trigger after the first successful task completion in a new session, when the user has just received value and hasn't yet started another task. For games, trigger after completing a level or winning a round — never on a loss, never mid-session.
Implementing satisfaction-triggered prompts requires tracking one additional variable: a boolean flag indicating that a qualifying completion event has occurred in this session. Set the flag when the event fires, then call requestReview() inside the flag's onChange handler with a brief async delay. Never call it synchronously in the same function as the completion event — the UI transition needs to settle before the system dialog appears.
What actually happens when the cap is hit — and why the sandbox lies
Testing the review prompt reveals an immediate discrepancy: in Simulator and in TestFlight builds, the system prompt appears every time you call it, with no cap enforcement. This is by design — Apple gives developers unrestricted prompt display in non-production environments. The problem arises when developers use this behavior to infer that their trigger logic is correct. Sandbox and Simulator confirm that the API call reaches the UI layer. They say nothing about whether your timing strategy will work at scale on real devices with the cap in effect.
One notable exception: on iOS 26.5 beta, Apple's developer forums documented a bug where the review prompt didn't display in debug builds even in Simulator under specific conditions (reported against beta 23F5043k). If you encounter this during development on iOS 26.5, verify against a release OS version on a real device. As of the iOS 26.5 release candidate, the behavior was confirmed fixed and does not affect production apps.
In production, the only way to verify that your timing strategy is working is indirectly: track App Store Connect's rating count before and after a release window where the timing change went live. App Store Connect Analytics shows ratings received by date — a meaningful uptick within two weeks of a timing change confirms prompts are reaching users in higher-satisfaction states. This indirect signal is imprecise but reliable for evaluating whether a prompt-timing change improved conversion.
Using all 3 prompts strategically: sequencing across the user lifecycle
With exactly three annual prompts, the highest-converting strategy treats each as a distinct opportunity rather than a repeated gamble. The first prompt should fire at the earliest reliable satisfaction milestone — typically the first successful meaningful action after the app has demonstrated its core value, often in the first week. The second should fire at a deeper engagement milestone: a streak, a return session after some days lapsed, or the moment a user discovers a secondary feature. The third should be held for a high-motivation event — a personal best, a significant export, an achievement unlocked — where the user is in maximum positive state.
Spacing matters independently of the cap. Showing prompts in quick succession — first on session 2, second on session 4 — trains users to dismiss without reading because the rhythm feels mechanical. Even if you haven't hit the cap, leave at least 30 days between prompts unless a significant milestone justifies a shorter interval. Users who returned to the app after a gap are particularly high-value targets for a second or third prompt: they've demonstrated persistence, and the act of returning often comes with renewed motivation. For how rating freshness feeds into App Store search ranking, the review velocity and ASO ranking guide explains why recent reviews outweight accumulated volume in Apple's algorithm.
Apps with strong early-session engagement but weak long-term retention should bias all three prompts earlier in the user lifecycle — users who churn by day 14 will never be available for a third prompt at a 30-day milestone. Apps with strong retention but slow value delivery (learning apps, language tools, habit trackers) should spread prompts across a longer arc: day 7, day 30, and a natural achievement event. The review response strategy guide covers what to do with the ratings you collect — including the response patterns that lift aggregate star averages over time.
When all 3 prompts are spent: the in-app feedback fallback
When all three annual prompts have been displayed and the user hasn't rated, the in-app review channel is closed for the year — any further system API calls are silently ignored. The correct response is a custom in-app feedback request on the fourth trigger event. The simplest version: show a lightweight custom view asking 'How is working for you?' with two options: 'Leave a review' (a deep link to the App Store listing) and 'Send us feedback' (a mailto: compose flow). This costs one screen and routes dissatisfied users into a conversation rather than into silence.
Implementing this requires tracking prompt display count yourself. Increment a UserDefaults integer each time requestReview() is called, and check at each trigger event: if promptCount < 3, call the system API; if promptCount >= 3, show the custom fallback. Note that app reinstallation resets UserDefaults while the system cap state persists from the original install date. For tighter alignment with the system window, track both the count and the first-prompt date, resetting both when 365 days have elapsed — this mirrors the rolling-window logic Apple uses internally and prevents your fallback from activating prematurely after a reinstall.
Three prompts are a constraint, not a suggestion
Apple's 3-per-365-day limit makes review prompt timing a consequential product decision. The difference between an app that earns 50 ratings per update cycle and one that earns 500 is usually the same three annual opportunities, used at the right moments versus the default ones. Satisfication-triggered prompts, properly spaced, are the highest-ROI change most apps can make to their review acquisition strategy without touching the product itself.
Before timing matters, the listing those reviews land on needs to be compelling. AppsTemple's editor lets you preview and iterate on screenshots, icons, and device frames at every App Store size — so when ratings improve from better prompt timing, the listing is ready to convert the users who arrive from improved search ranking.
Build your App Store listing assets in the editor →
Frequently asked questions
how many times can i show the ios review prompt per year?
Apple allows the review prompt to display up to 3 times per device per 365-day rolling period. The window resets 365 days after the first display on that device — not on January 1 or on the app's install anniversary. If a user reinstalls the app, their UserDefaults may reset but the system-level cap state persists; reinstallation does not reset Apple's internal prompt count.
can i detect if the user rated after the ios review prompt appeared?
No. Apple does not expose the user's response to your app. You cannot determine whether the user dismissed the dialog, tapped to rate, or left a specific rating. The only indirect signal available is aggregate: App Store Connect Analytics shows ratings received by date, so a meaningful uptick after a timing change confirms prompts are reaching users in positive states — but you cannot attribute a specific rating to a specific prompt event.
does the review prompt work in simulator or testflight?
In Simulator and TestFlight builds, the system prompt appears every time you call it — cap enforcement does not apply in these environments. This lets you verify the UI renders correctly, but it does not reflect production behavior. Only release builds running on real devices enforce the 3-per-365-days limit. An iOS 26.5 beta bug caused prompts not to show in debug builds under some conditions; this was fixed before release and does not affect production apps.
what happens if i call requestreview after the 3 prompt limit is reached?
The call is silently ignored. No error is thrown, no callback fires, the user sees nothing, and your code continues executing normally. There is no built-in way to query whether the cap has been reached from within your app. Track prompt count and first-prompt date yourself using UserDefaults to implement a custom in-app feedback fallback once the cap is exhausted.
is skstorerequestcontroller requestreview deprecated in ios 18?
Yes. Apple deprecated SKStoreReviewController.requestReview(in:) in iOS 18. The replacements are AppStore.requestReview(in:) for UIKit-based apps (available from iOS 16, imported from StoreKit), and the @Environment(\.requestReview) property wrapper for SwiftUI apps (also iOS 16+). Both have identical cap behavior — 3 prompts per 365 days — and identical silent enforcement. Apps still using the deprecated UIKit class will continue to work but should migrate to avoid future SDK warnings.