Page updated Nov 15, 2023

Set up Amplify Auth

Amplify Flutter v0 is now in Maintenance Mode until July 19th, 2024. This means that we will continue to include updates to ensure compatibility with backend services and security. No new features will be introduced in v0.

Please use the latest version (v1) of Amplify Flutter to get started.

If you are currently using v0, follow these instructions to upgrade to v1.

The Amplify Auth category provides an interface for authenticating a user. Behind the scenes, it provides the necessary authorization to the other Amplify categories. It comes with default, built-in support for Amazon Cognito User Pool and Identity Pool. The Amplify CLI helps you create and configure the auth category with an authentication provider.


To setup and configure your application with Amplify Auth and go through a simple api to check the current auth session.


A Flutter application targeting Flutter SDK >= 2.10.0 with Amplify libraries integrated.

The following are also required, depending on which platforms you are targeting:

  • An iOS configuration targeting at least iOS 11.0
  • An Android configuration targeting at least Android API level 21 (Android 5.0) or above

For a full example please follow the project setup walkthrough

Install Amplify Libraries

Add the following dependency to your app's pubspec.yaml along with others you added above in Prerequisites:

environment: sdk: ">=2.15.0 <3.0.0" dependencies: flutter: sdk: flutter amplify_flutter: ^0.6.0 amplify_auth_cognito: ^0.6.0
2 sdk: ">=2.15.0 <3.0.0"
5 flutter:
6 sdk: flutter
8 amplify_flutter: ^0.6.0
9 amplify_auth_cognito: ^0.6.0

Set Up Backend Resources

The most common way to use Authentication with Amplify is via the Amplify CLI, which allows you to create new Amazon Cognito resources or import existing ones. However, you can also use the Amplify Studio console to configure authentication or use the Amplify.configure() method to set up authentication with existing resources.

Prerequisites: Install and configure the Amplify CLI in addition to the Amplify libraries and necessary dependencies.

To start provisioning auth resources in the backend, go to your project directory and execute the command:

amplify add auth
1amplify add auth

Enter the following when prompted:

? Do you want to use the default authentication and security configuration? `Default configuration` ? How do you want users to be able to sign in? `Username` ? Do you want to configure advanced settings? `No, I am done.`
1? Do you want to use the default authentication and security configuration?
2 `Default configuration`
3? How do you want users to be able to sign in?
4 `Username`
5? Do you want to configure advanced settings?
6 `No, I am done.`

If you have previously enabled an Amplify category that uses Auth behind the scenes (e.g. API category), you can run the amplify update auth command to edit your configuration if needed.

To push your changes to the cloud, execute the command:

amplify push
1amplify push

Upon completion, amplifyconfiguration.dart should be updated to reference provisioned backend auth resources. Note that these files should already be a part of your project if you followed the Project setup walkthrough.

Initialize Amplify Auth

Add the Auth plugin, along with any other plugins you may have added as described in the Prerequisites section. To complete initialization call Amplify.configure().

Your code should look like this:

import 'package:amplify_flutter/amplify_flutter.dart'; import 'package:amplify_auth_cognito/amplify_auth_cognito.dart'; import 'package:flutter/material.dart'; import 'amplifyconfiguration.dart'; void main() { runApp(const MyApp()); } class MyApp extends StatefulWidget { const MyApp({Key? key}) : super(key: key); @override State<MyApp> createState() => _MyAppState(); } class _MyAppState extends State<MyApp> { @override void initState() { super.initState(); _configureAmplify(); } Future<void> _configureAmplify() async { try { final auth = AmplifyAuthCognito(); await Amplify.addPlugin(auth); // call Amplify.configure to use the initialized categories in your app await Amplify.configure(amplifyconfig); } on Exception catch (e) { safePrint('An error occurred configuring Amplify: $e'); } } @override Widget build(BuildContext context) { return const MaterialApp( home: Scaffold( body: SizedBox(), ), ); } }
1import 'package:amplify_flutter/amplify_flutter.dart';
2import 'package:amplify_auth_cognito/amplify_auth_cognito.dart';
3import 'package:flutter/material.dart';
5import 'amplifyconfiguration.dart';
7void main() {
8 runApp(const MyApp());
11class MyApp extends StatefulWidget {
12 const MyApp({Key? key}) : super(key: key);
15 State<MyApp> createState() => _MyAppState();
18class _MyAppState extends State<MyApp> {
20 void initState() {
21 super.initState();
22 _configureAmplify();
23 }
25 Future<void> _configureAmplify() async {
26 try {
27 final auth = AmplifyAuthCognito();
28 await Amplify.addPlugin(auth);
30 // call Amplify.configure to use the initialized categories in your app
31 await Amplify.configure(amplifyconfig);
32 } on Exception catch (e) {
33 safePrint('An error occurred configuring Amplify: $e');
34 }
35 }
38 Widget build(BuildContext context) {
39 return const MaterialApp(
40 home: Scaffold(
41 body: SizedBox(),
42 ),
43 );
44 }

Authentication with Amplify

There are 2 options to add authentication capabilities to your application:

  • Option 1: Use Amplify Authenticator UI Library
  • Option 2: Call Authentication APIs manually

Option 1: Use Authenticator UI Library

The Amplify Authenticator UI library allows you to quickly create an authentication/registration flow within your app. The experience generated within your app will be determined by the amplifyconfiguration.dart file that is automatically generated for you after initializing your app, and adding auth or other categories.

Visit to get started.

Option 2: Call Authentication APIs manually

Follow the instructions in Sign In to learn about how to integrate these authentication flows in your application with the Auth APIs.

Check the current auth session

You can now check the current auth session.

After implementing Authentication in your app, you can check if a user is logged in. CognitoAuthSession will have the isSignedIn property set to false if the user has not signed in to your app. You can see how it works by using the below function:

Future<bool> isUserSignedIn() async { final result = await Amplify.Auth.fetchAuthSession(); return result.isSignedIn; }
1Future<bool> isUserSignedIn() async {
2 final result = await Amplify.Auth.fetchAuthSession();
3 return result.isSignedIn;

In case you want to get the current user information, you can use the code below:

Future<AuthUser> getCurrentUser() async { final user = await Amplify.Auth.getCurrentUser(); return user; }
1Future<AuthUser> getCurrentUser() async {
2 final user = await Amplify.Auth.getCurrentUser();
3 return user;

AuthUser will have the userId and username will have the user details if they were logged in.

The isSignedIn property of the authSession will be false since you haven't signed in to the category yet.

Next Steps

Congratulations! You've successfully setup AWS Cognito Auth plugin. Check out the following links to see other Amplify Auth use cases: