Home Pricing Explore MCP Docs Create a project

Flutter Age Verification: Play Age Signals and Declared Age Range

Flutter age verification: where Texas, Utah and Louisiana app store laws stand, what Play Age Signals and Declared Age Range return, and tested Dart code.

Flutter Age Verification: Play Age Signals and Declared Age Range

Flutter age verification now means reading an age range from the app store. Texas's app store law has applied to new Texas store accounts since early June 2026 (late May on Google Play). Android apps read the range through the Play Age Signals API, and iOS apps through Apple's Declared Age Range framework.

Flutter has no first-party plugin for either, so you add a community plugin or a small platform channel of your own. This article shows where each US law stands as of 18 October 2026, what the two APIs return, and a tested Dart layer: a typed signal, a channel, a gate policy and a fake for tests.

Not legal advice. This is an engineering summary of public court records, bill texts and store documentation. Whether a law applies to your app, and what it requires of you, is a question for your own lawyer.

Key takeaways

  • Texas SB 2420 is enforceable today. The appeal itself is still undecided.
  • Utah and Louisiana have pushed their app store laws back to 6 May 2027 and 1 July 2027.
  • Write your fallback for "no signal" first. Outside places with these laws, many users will share nothing.
Flow from the store account to the native API, then a platform channel, then a Flutter UI gate
How the pieces in this article connect: the store account, the native API, one platform channel and a Flutter gate. Diagram by FlutterGo.

Where the US app store age laws stand

Texas is in force. The other states have dates in 2027. This is the position on 18 October 2026.

State Law Status on 18 Oct 2026 Key date
Texas SB 2420, App Store Accountability Act (Bus. & Com. Code ch. 121) Enforceable. A district court injunction is stayed while the appeal runs. Apple: new Texas accounts from 4 Jun 2026. Play: Texas accounts created after 28 May 2026.
Utah SB 142 (2025), amended by H.B. 498 (2026) Store and developer duties delayed. Enforcement is now private lawsuits only. 6 May 2027
Louisiana HB 977 (2026) replaces Act 481 of 2025 (HB 570) The 2025 Act will not take effect. A rewritten Act replaces it. 1 Jul 2027
Alabama HB 161 (2026) Enacted. Attorney general enforcement. 1 Jan 2027 (law firm summaries)
California AB 1043, Digital Age Assurance Act (2025); amended by AB 1856 (2026) Enacted. Puts the duty on operating system providers and app stores to send a signal. 1 Jan 2027 (law firm summaries)
Timeline of US app store age law dates from December 2025 to July 2027, with today marked
Court and store dates for Texas, and start dates in the other state laws, as of 18 October 2026. Sources are listed in the image and in this article. Not legal advice.

Texas. A federal district court blocked SB 2420 on 23 December 2025 (CCIA), and Apple paused its Texas rollout the same day (Apple Developer News). The Fifth Circuit entered an administrative stay on 28 May 2026 and a stay pending appeal on 4 June, according to CCIA's own emergency application (Supreme Court filing). The Supreme Court declined to vacate that stay on 6 July 2026 (docket 25A1390), which is not a ruling on whether the law is constitutional.

The stores moved fast. Apple applies the law to new Texas accounts from 4 June 2026 (Apple Developer News), and Play returns signals for eligible Texas accounts created after 28 May 2026 (Android Developers). Google's help page says the law "is now in effect" (Play Console Help).

Utah and Louisiana. Utah's H.B. 498 opens each store and developer duty with "Beginning May 6, 2027" and leaves enforcement to lawsuits by a harmed minor or their parent (H.B. 498 enrolled, §§ 13-76-201, -202, -401). CCIA then dropped its suit against the original Act (CCIA).

Louisiana's HB 977 says Act 481 of 2025 "shall not become effective" and enacts a new Act from 1 July 2027. The attorney general enforces it, with fines up to $10,000 per violation (HB 977 enrolled).

Alabama and California. We relied on law firm summaries here, because the state bill pages were unreachable from our tools. Alabama's HB 161 takes effect on 1 January 2027 (Hunton). California's AB 1043 makes operating systems collect an age at setup and send a signal to developers who ask, from 1 January 2027. A developer who receives it is treated as knowing the user's age range (Kelley Drye). AB 1856, signed on 10 September 2026, exempts open-source operating systems (Kelley Drye).

What these laws ask of app developers

The store checks the age and collects parental consent. Your app reads the result and acts on it. The state texts share a common shape:

  • Use the store's age category to verify age and a minor's parental consent. Utah § 13-76-202(1); Louisiana R.S. 51:1773.
  • Tell the store about significant changes. For a minor, that can mean asking the parent again. Texas §§ 121.022(g), 121.053, per CCIA's filing.
  • Use the age data narrowly. Utah limits its use and bans sharing it (§ 13-76-202(4)-(5)); Louisiana bans selling it.
  • Don't ask too often. Outside listed triggers such as download, purchase and significant changes, Utah and Louisiana allow a new request at most once every 12 months.
  • Rate in-app items. Texas requires an age rating for each app and in-app purchase item (§ 121.052(a), per CCIA's filing). Play lets you rate purchase SKUs in Play Console (Play Console Help). Our Google Play publishing guide covers the Console basics.
  • Safe harbour. Utah (§ 13-76-402) and Louisiana (R.S. 51:1774) protect developers who rely on the store's signal in good faith. Morrison Foerster describes a similar rule in Texas (MoFo).

Both stores leave the hardest call to you. Apple says it's "the developer's responsibility to determine when there is a significant change" (Apple). Google says Play "doesn't mandate the use of these features" (Play Console Help).

What Play Age Signals and Declared Age Range return

Both APIs return an age range and a note on how the age was set, never a birth date. The table compares them field by field.

Google Play Age Signals Apple Declared Age Range
Status Beta, library com.google.android.play:age-signals:0.0.4 Framework in iOS, iPadOS, macOS and Mac Catalyst 26.0+
Minimum OS Android 6.0 (API 23) 26.0. Eligibility check needs 26.2; regulatory features need 26.4
Setup Gradle dependency. The app must come from Play, or the tester must be a license tester. com.apple.developer.declared-age-range entitlement (Declared Age Range capability)
Calls requestAgeSignalsAccess(), then checkAgeSignals() AgeRangeService.shared.requestAgeRange(ageGates:_:_:in:)
Age bands Default 0-12, 13-15, 16-17, 18+. Up to three custom minimum ages in Play Console. Up to three age gates per request. The system may adjust them to local rules.
How the age was set ageRangeSource: TIER_A self-declared, TIER_B parent-managed, TIER_C assessed (card, email, selfie, ID), TIER_D ID plus selfie, or digital ID ageRangeDeclaration: selfDeclared, guardianDeclared, confirmed (older …Checked cases are deprecated)
Significant changes significantChangeStatus (APPROVED, PENDING, DECLINED) and an approval date. You report changes in Play Console. PermissionKit SignificantAppUpdateTopic. On 26.4+, requiredRegulatoryFeatures tells you if consent or adult notice applies.
Revoked consent installId plus a revoked-approvals report in Play Console App Store Server Notification RESCIND_CONSENT. Apple blocks the app from launching.
Test without real users FakeAgeSignalsManager; license testers for real calls Sandbox scenarios on iOS 26.2+

Sources: Use Play Age Signals API, Request age signals, Understand responses, Test your integration, Declared Age Range, Age assurance developer Q&A. All read 18 October 2026.

Details that change how you write the gate

Play has a third status. requestAgeSignalsAccess can return VERIFICATION_REQUIRED: verification is mandatory where the user is, and Play doesn't know their age yet. In US states with these laws, the user sorts it out in the Play Store, not in your app (Request age signals). Your UI needs a "go to the Play Store" state that isn't "declined".

A child below your lowest gate looks different on each platform. Play's default bands report ageLower: 0, ageUpper: 12. Apple's sample treats a missing lowerBound as "under 13" (AgeRangeService). Our Dart model maps both to a lower bound of 0.

Outside regulated places, sharing is opt-in. Where no law requires it, Apple shares ranges only from people who chose to (Apple Q&A), so expect "declined" or "unavailable" often.

A plugin or your own platform channel?

We found no plugin from the Flutter team or Google for either API. On pub.dev, one community plugin covers both.

age_range_signals
Version and date 0.10.1, published 6 Oct 2026
Publisher povhe.si (verified publisher). Source: github.com/zigapovhe/age_range_signals
Licence MIT
Platforms Android (minSdk 23) and iOS (app target 13.0; the API itself needs iOS 26+)
Wraps Play Age Signals 0.0.4; DeclaredAgeRange, including isEligibleForAgeFeatures, regulatory features and the significant update sheet
Constraints Dart ^3.12.0, Flutter >=3.44.0
Testing useMockData uses Play's fake manager on Android only. Since 0.8.0 it throws outside debuggable builds.

Sources: pub.dev and its pubspec.yaml and CHANGELOG.md at main, read 18 October 2026.

It's an active, well-documented package that tracks both APIs closely. Pin the version anyway: several releases include breaking changes, Play's API is still beta, and a single-publisher package in your compliance path deserves review on every update.

Write your own channel if you want native code you can audit line by line. Either way, put the store behind the AgeSignalsApi interface below, and your UI and tests won't change.

Building the age gate in Dart (tested)

Our small package has a typed AgeSignal, an AgeSignalsApi interface with a MethodChannel implementation, a pure decide() policy and an AgeGate widget. FakeAgeSignals stands in for the store in tests.

The model

The native side sends a map. fromMap turns it into a typed value and throws on anything malformed, so a native bug can't quietly become "adult". This is an excerpt; the full file also has equality and toString.

enum AgeSharing { shared, notShared, verificationRequired, unavailable }
enum AgeSource { selfDeclared, guardianSet, checked, unknown }
enum ChangeApproval { approved, pending, declined, notApplicable }

@immutable
class AgeSignal {
  const AgeSignal({
    required this.sharing,
    this.ageLower,
    this.ageUpper,
    this.source = AgeSource.unknown,
    this.changeApproval = ChangeApproval.notApplicable,
    this.installId,
    this.rawSource,
  });

  const AgeSignal.unavailable() : this(sharing: AgeSharing.unavailable);

  factory AgeSignal.fromMap(Map<Object?, Object?> map) {
    final sharing = switch (map['sharing']) {
      'shared' => AgeSharing.shared,
      'notShared' => AgeSharing.notShared,
      'verificationRequired' => AgeSharing.verificationRequired,
      'unavailable' => AgeSharing.unavailable,
      final Object? other =>
        throw FormatException('Unknown sharing value: $other'),
    };

    var lower = _optionalInt(map, 'ageLower');
    final upper = _optionalInt(map, 'ageUpper');

    // Apple leaves lowerBound empty for people under your lowest age gate,
    // while Play reports 0. Use 0 for both.
    if (lower == null && upper != null) lower = 0;

    if (lower != null && upper != null && lower > upper) {
      throw FormatException('ageLower ($lower) is above ageUpper ($upper)');
    }

    return AgeSignal(
      sharing: sharing,
      ageLower: lower,
      ageUpper: upper,
      source: switch (map['source']) {
        'selfDeclared' => AgeSource.selfDeclared,
        'guardianSet' => AgeSource.guardianSet,
        'checked' => AgeSource.checked,
        _ => AgeSource.unknown,
      },
      changeApproval: switch (map['significantChange']) {
        'approved' => ChangeApproval.approved,
        'pending' => ChangeApproval.pending,
        'declined' => ChangeApproval.declined,
        _ => ChangeApproval.notApplicable,
      },
      installId: _optionalString(map, 'installId'),
      rawSource: _optionalString(map, 'rawSource'),
    );
  }

  final AgeSharing sharing;
  final int? ageLower; // inclusive
  final int? ageUpper; // inclusive; null for the open top band, such as 18+
  final AgeSource source;
  final ChangeApproval changeApproval;
  final String? installId;
  final String? rawSource; // the store's own value, for logs

  /// True only when the store says the user is at least [age].
  bool isAtLeast(int age) {
    final lower = ageLower;
    return sharing == AgeSharing.shared && lower != null && lower >= age;
  }

  /// True only when the store says the user is younger than [age].
  bool isBelow(int age) {
    final upper = ageUpper;
    return sharing == AgeSharing.shared && upper != null && upper < age;
  }

  static int? _optionalInt(Map<Object?, Object?> map, String key) {
    final value = map[key];
    if (value == null || value is int) return value as int?;
    throw FormatException('$key must be an int, got ${value.runtimeType}');
  }

  static String? _optionalString(Map<Object?, Object?> map, String key) {
    final value = map[key];
    if (value == null || value is String) return value as String?;
    throw FormatException('$key must be a String, got ${value.runtimeType}');
  }
}

AgeSource is deliberately coarse: Play's TIER_C and TIER_D and Apple's confirmed all become checked, and the store's own value stays in rawSource. Branch on rawSource if you must tell an ID check from a card check.

The channel and the policy

The UI depends on an interface, never on the channel. The channel turns platform errors into a typed failure:

abstract interface class AgeSignalsApi {
  Future<AgeSignal> check({List<int> ageGates});
}

class AgeSignalsFailure implements Exception {
  const AgeSignalsFailure(this.code, [this.message]);
  final String code;
  final String? message;
}

class MethodChannelAgeSignals implements AgeSignalsApi {
  MethodChannelAgeSignals({MethodChannel? channel})
      : _channel = channel ?? const MethodChannel(channelName);

  static const channelName = 'fluttergo.dev/age_signals';
  static const defaultGates = [13, 16, 18];

  final MethodChannel _channel;

  @override
  Future<AgeSignal> check({List<int> ageGates = defaultGates}) async {
    _checkGates(ageGates);
    try {
      final map = await _channel.invokeMapMethod<Object?, Object?>(
        'checkAgeSignals',
        {'ageGates': ageGates},
      );
      return map == null ? const AgeSignal.unavailable() : AgeSignal.fromMap(map);
    } on MissingPluginException {
      // Web, desktop, tests, or a build without the native code.
      return const AgeSignal.unavailable();
    } on PlatformException catch (e) {
      throw AgeSignalsFailure(e.code, e.message);
    }
  }

  static void _checkGates(List<int> gates) {
    if (gates.isEmpty || gates.length > 3) {
      throw ArgumentError.value(gates, 'ageGates', 'Pass one to three ages');
    }
    for (var i = 1; i < gates.length; i++) {
      if (gates[i] <= gates[i - 1]) {
        throw ArgumentError.value(gates, 'ageGates', 'Ages must go up');
      }
    }
  }
}

The gates only matter on iOS. Play takes its bands from the defaults or your Play Console custom ranges: up to three minimum ages, at least two years apart, changeable once a year (Understand responses). Keep the two in step, or one user lands in different bands on each platform.

Keep the decision out of the widget. A pure function can be tested as a table:

enum GateDecision { allow, restrict, waitForParent, verifyInStore, fallback }

GateDecision decide(AgeSignal signal, {required int minimumAge}) {
  switch (signal.sharing) {
    case AgeSharing.verificationRequired:
      return GateDecision.verifyInStore;
    case AgeSharing.notShared:
    case AgeSharing.unavailable:
      return GateDecision.fallback;
    case AgeSharing.shared:
      break;
  }

  if (signal.changeApproval == ChangeApproval.pending ||
      signal.changeApproval == ChangeApproval.declined) {
    return GateDecision.waitForParent;
  }
  if (signal.isAtLeast(minimumAge)) return GateDecision.allow;
  if (signal.isBelow(minimumAge)) return GateDecision.restrict;

  // The band straddles minimumAge (say 16-17 with a minimum of 17), or the
  // store shared no bounds. Don't guess either way.
  return GateDecision.fallback;
}

fallback matters most. It's whatever your app does today when it doesn't know someone's age, a product and legal call the code shouldn't make for you. AgeGate takes allowed, restricted and fallback builders and calls the API once per mount.

The fake and what we ran

class FakeAgeSignals implements AgeSignalsApi {
  FakeAgeSignals(AgeSignal this.next) : error = null;
  FakeAgeSignals.failing(Object this.error) : next = null;

  AgeSignal? next;
  Object? error;
  int calls = 0;
  List<int>? lastGates;

  @override
  Future<AgeSignal> check({List<int> ageGates = const [13, 16, 18]}) async {
    calls++;
    lastGates = ageGates;
    final e = error;
    if (e != null) throw e;
    return next!;
  }
}

On Flutter 3.47.7 (stable, Dart 3.13.5, Linux, flutter_lints 6.0.0), flutter analyze reported no issues, and flutter test passed 24 of 24: 10 policy cases, 5 model tests, 4 channel tests and 5 widget tests against the fake. When we loosened isAtLeast by one year, the "16-17 straddles minimum 17" case failed as it should. We didn't run the channel on a device, emulator or simulator.

The native halves (not compiled)

The Kotlin and Swift sides follow the official docs and Flutter 3.47.7's templates, but we haven't compiled them. Treat them as a starting point.

  • Android. In MainActivity, call requestAgeSignalsAccess, then checkAgeSignals only on SHARED, and map the tiers to the Dart keys. Real calls fail with APP_NOT_OWNED unless the app came from Play or the account is a license tester (Test your integration).
  • iOS. Enable the Declared Age Range capability. Flutter 3.47's template registers plugins in didInitializeImplicitFlutterEngine, so register the channel there. Our UIScene and Xcode 27 guide covers that migration.

Which apps need what

Your app Do now Watch
On the App Store or Play in the US, so available in Texas Rate in-app purchase items. Define a "significant change" and who signs off. Handle Apple's consent-revoked notification and Play's revoked-approvals report. The Fifth Circuit's merits ruling on SB 2420
Has age-based features: mature content, chat with strangers, adult purchases Read the signal at download, purchase and significant change. Gate with decide(), with a fallback for no signal. Utah and Louisiana in 2027; Play API changes while it's in beta
Rated 18+ Apple says 18+ apps still need to implement the API where the law requires it (Q&A) Same as above
Made for kids or families Expect guardianSet sources and pending approvals; test waitForParent with the fake. Significant-change approvals per install
Flutter web or desktop only No store signal reaches you; the channel returns unavailable. California's OS-level signal from 2027
Pre-installed or distributed outside the stores These laws are written around app stores. Get advice on your own channel. Utah H.B. 498 now covers apps already on a device at setup, per McDermott

Limitations and open questions

These points are still uncertain, so watch them:

  • Texas could change again. The stay lasts only while the appeal runs, and a ruling for CCIA would likely block the law again. We found no merits ruling by 18 October.
  • Does an API call count as a "request"? Neither the Utah nor the Louisiana text says whether reading a store signal counts toward the 12-month limit. Until you have advice, cache the result and call at defined moments, not on every launch.
  • What will Apple do in Utah and Louisiana? Apple's February 2026 notice set sharing dates in 2026, before both states delayed. We found no later notice.
  • How will California's signal reach apps? Neither store has published how it will deliver the AB 1043 signal.
  • The native code is untested, and Play's API is beta. Version 0.0.4 already replaced 0.0.3's userStatus field with ageRangeSource, per the plugin's changelog.

Where this leaves a Flutter team

The store APIs are the reliable part. The legal timeline isn't. Build the gate so the law can change without a rewrite: one typed signal, one policy, a fake, and a deliberate fallback. Whether you wrap age_range_signals or keep your own channel, put it behind an interface like AgeSignalsApi, so a breaking release or a new state touches one file. Then cover the gate with widget tests for AI-generated Flutter code.

Starting a new app? Our AI Flutter app builder produces ordinary Flutter code, so these files drop in like any other project.

Written by

Engineering, FlutterGo

The engineers behind FlutterGo's code generation, live preview and builds. We write about how it works and what we learn building it.

Stop reading. Start building.

Describe the app you want in plain English. FlutterGo designs it, writes real Flutter code, and gets it ready for the App Store and Google Play.