Local Data Storage means saving application data directly on the user's device so that the data can be accessed later without requesting it again from a remote server. Flutter provides several approaches for local persistence depending on the type and amount of data that needs to be stored.
Local storage is useful for saving user preferences, login states, application settings, cached information, offline data, files, and structured records. Flutter's persistence options include key-value storage, local files, and SQLite databases.
Local Data Storage is the process of storing information on the device where the Flutter application is installed.
For example, an application may need to remember:
User Action
↓
Flutter Application
↓
Local Storage Layer
↓
Device Storage
↓
Data remains available for later use| Storage Method | Best Used For | Example |
|---|---|---|
| SharedPreferences | Small key-value data | Theme, language, onboarding status |
| File Storage | Files and text data | JSON, text files, downloaded documents |
| SQLite | Structured and relational data | Products, users, orders, tasks |
| Secure Storage | Sensitive values | Tokens and credentials |
| Cache | Temporary/reusable data | Images and API responses |
The correct storage method depends on the type, size, structure, lifetime, and security requirements of the data.
shared_preferences is commonly used when an application needs to store a relatively small collection of key-value pairs. Flutter's documentation describes it as a solution for simple persistent key-value data.
flutter pub add shared_preferencesimport 'package:shared_preferences/shared_preferences.dart';| Type | Example | Method |
|---|---|---|
| String | Manish | setString() |
| int | 25 | setInt() |
| double | 99.50 | setDouble() |
| bool | true | setBool() |
| List | ["Flutter","Dart"] | setStringList() |
final prefs = await SharedPreferences.getInstance();
await prefs.setString('username', 'Manish');
final prefs = await SharedPreferences.getInstance();
String username = prefs.getString('username') ?? 'Guest';
print(username);
await prefs.setInt('age', 25);int age = prefs.getInt('age') ?? 0;await prefs.setBool('isLoggedIn', true);bool isLoggedIn = prefs.getBool('isLoggedIn') ?? false;await prefs.setDouble('price', 499.99);double price = prefs.getDouble('price') ?? 0.0;await prefs.setStringList(
'skills',
['Flutter', 'Dart', 'Firebase'],
);List skills =
prefs.getStringList('skills') ?? []; import 'package:flutter/material.dart';
import 'package:shared_preferences/shared_preferences.dart';
void main() {
runApp(const MyApp());
}
class MyApp extends StatelessWidget {
const MyApp({super.key});
@override
Widget build(BuildContext context) {
return MaterialApp(
debugShowCheckedModeBanner: false,
home: const StoragePage(),
);
}
}
class StoragePage extends StatefulWidget {
const StoragePage({super.key});
@override
State createState() => _StoragePageState();
}
class _StoragePageState extends State {
String username = '';
Future saveData() async {
final prefs = await SharedPreferences.getInstance();
await prefs.setString('username', 'Manish');
setState(() {
username = 'Manish';
});
}
Future loadData() async {
final prefs = await SharedPreferences.getInstance();
setState(() {
username = prefs.getString('username') ?? 'No Data';
});
}
Future removeData() async {
final prefs = await SharedPreferences.getInstance();
await prefs.remove('username');
setState(() {
username = 'Data Removed';
});
}
@override
Widget build(BuildContext context) {
return Scaffold(
appBar: AppBar(
title: const Text('Local Storage'),
),
body: Padding(
padding: const EdgeInsets.all(20),
child: Column(
children: [
Text(
'Username: $username',
style: const TextStyle(fontSize: 20),
),
const SizedBox(height: 20),
ElevatedButton(
onPressed: saveData,
child: const Text('Save Data'),
),
ElevatedButton(
onPressed: loadData,
child: const Text('Load Data'),
),
ElevatedButton(
onPressed: removeData,
child: const Text('Remove Data'),
),
],
),
),
);
}
}
The remove() method removes a particular key and its associated value.
final prefs = await SharedPreferences.getInstance();
await prefs.remove('username');
final prefs = await SharedPreferences.getInstance();
if (prefs.containsKey('username')) {
print('Username exists');
}
final prefs = await SharedPreferences.getInstance();
await prefs.clear();
Use clear() carefully because it removes all stored preference values managed by that preference store.
A simple login state can be stored as a boolean value.
final prefs = await SharedPreferences.getInstance();
await prefs.setBool('isLoggedIn', true);
Later, the application can read the value:
final prefs = await SharedPreferences.getInstance();
bool isLoggedIn = prefs.getBool('isLoggedIn') ?? false;
if (isLoggedIn) {
print('User is logged in');
} else {
print('User is logged out');
}
A simple preference flag is not the same as securely storing authentication credentials. Passwords, private keys, and other sensitive secrets should not be stored as ordinary SharedPreferences values.
Many applications display onboarding screens only the first time the application is opened.
final prefs = await SharedPreferences.getInstance();
bool completed =
prefs.getBool('onboardingCompleted') ?? false;
After the user finishes onboarding:
await prefs.setBool('onboardingCompleted', true);On the next application launch, the application can check this value and decide whether to display onboarding or the main screen.
Local storage can remember whether the user selected dark mode.
final prefs = await SharedPreferences.getInstance();
await prefs.setBool('darkMode', true);
Read the value:
final prefs = await SharedPreferences.getInstance();
bool darkMode = prefs.getBool('darkMode') ?? false;
This type of key-value storage is appropriate for simple application configuration such as theme settings.
SharedPreferences is designed for simple supported types. If an application needs to store a small object, the object can be converted to JSON and then stored as a String.
import 'dart:convert';
Map user = {
'name': 'Manish',
'age': 25,
'city': 'Mumbai',
};
final prefs = await SharedPreferences.getInstance();
await prefs.setString(
'user',
jsonEncode(user),
);
final prefs = await SharedPreferences.getInstance();
String? data = prefs.getString('user');
if (data != null) {
Map user = jsonDecode(data);
print(user['name']);
print(user['age']);
}
JSON stored in a key-value store can be useful for small objects, but it is not a replacement for a proper database when the application contains large or complex datasets.
When an application needs to store actual files or larger text content, file storage can be used. Flutter's path_provider package provides commonly used filesystem locations, while Dart's dart:io provides the File API for reading and writing files on supported mobile and desktop platforms.
flutter pub add path_providerimport 'dart:io';
import 'package:path_provider/path_provider.dart';Future getApplicationDirectory() async {
return await getApplicationDocumentsDirectory();
} Future saveFile() async {
final directory =
await getApplicationDocumentsDirectory();
final file = File('${directory.path}/data.txt');
await file.writeAsString('Hello Flutter');
}
Future readFile() async {
final directory =
await getApplicationDocumentsDirectory();
final file = File('${directory.path}/data.txt');
if (await file.exists()) {
return await file.readAsString();
}
return '';
}
When the application needs structured data, relationships, filtering, sorting, and database queries, SQLite is a suitable local persistence approach.
Flutter documentation demonstrates SQLite persistence using the sqflite package. It is particularly useful for applications that need to store and query larger amounts of structured data.
flutter pub add sqflite pathimport 'package:path/path.dart';
import 'package:sqflite/sqflite.dart';final database = await openDatabase(
join(
await getDatabasesPath(),
'app_database.db',
),
version: 1,
);final database = await openDatabase(
join(
await getDatabasesPath(),
'app_database.db',
),
version: 1,
onCreate: (db, version) async {
await db.execute(
'CREATE TABLE users('
'id INTEGER PRIMARY KEY, '
'name TEXT, '
'email TEXT'
')',
);
},
);await database.insert(
'users',
{
'name': 'Manish',
'email': '[email protected]',
},
);final users = await database.query('users');
for (final user in users) {
print(user);
}
await database.update(
'users',
{
'name': 'Manish Negi',
},
where: 'id = ?',
whereArgs: [1],
);await database.delete(
'users',
where: 'id = ?',
whereArgs: [1],
);| Feature | SharedPreferences | File Storage | SQLite |
|---|---|---|---|
| Data Type | Simple key-value | Files/text | Structured records |
| Complex Queries | No | No | Yes |
| Relationships | No | No | Yes |
| Best For | Settings and preferences | Documents and files | Large structured data |
| Example | Dark mode | PDF/document | Product database |
| SQL Support | No | No | Yes |
What type of data do you need to store?
|
+-- Simple key-value?
| |
| +-- Use SharedPreferences
|
+-- Files or text?
| |
| +-- Use File Storage
|
+-- Structured records?
|
+-- Use SQLite / Database| Requirement | Recommended Approach |
|---|---|
| Dark mode setting | SharedPreferences |
| Selected language | SharedPreferences |
| Onboarding completed flag | SharedPreferences |
| Downloaded text file | File Storage |
| Generated PDF | File Storage |
| Thousands of products | SQLite |
| Orders and customers | SQLite |
| Relational data | SQLite |
Local storage plays an important role in offline-first applications. An application can save information locally and display it even when the network is temporarily unavailable.
Internet Available
↓
Fetch Data from API
↓
Save Data Locally
↓
Display Data
↓
Internet Unavailable
↓
Read Cached/Stored Data
↓
Display Previously Saved DataThis approach can improve the user experience because the application does not always have to wait for a network response before displaying previously available information.
Instead of directly calling SharedPreferences from every widget, it is often cleaner to create a separate service class responsible for local storage.
import 'package:shared_preferences/shared_preferences.dart';
class StorageService {
Future saveUsername(String username) async {
final prefs = await SharedPreferences.getInstance();
await prefs.setString('username', username);
}
Future getUsername() async {
final prefs = await SharedPreferences.getInstance();
return prefs.getString('username') ?? '';
}
Future removeUsername() async {
final prefs = await SharedPreferences.getInstance();
await prefs.remove('username');
}
}
For larger applications, a repository can act as the application's interface to stored data.
UI
↓
ViewModel / Controller
↓
Repository
↓
Local Storage Service
↓
SharedPreferences / SQLite / File StorageThis architecture prevents UI components from becoming tightly coupled to a particular storage package.
Local storage should not automatically be considered secure storage.
Avoid storing highly sensitive information in ordinary key-value storage without appropriate protection.
SharedPreferences is intended for relatively small key-value data, not large databases.
Ordinary local preferences should not be treated as a secure password vault.
Many local-storage operations are asynchronous and should be handled with async and await.
Future saveData() async {
final prefs = await SharedPreferences.getInstance();
await prefs.setString('name', 'Manish');
} The type used for reading should correspond to the type used when storing the value.
await prefs.setInt('age', 25);
int age = prefs.getInt('age') ?? 0;
For larger applications, separate storage operations into services or repositories instead of putting all persistence code directly inside widgets.
Consider a Flutter shopping application.
| Data | Storage |
|---|---|
| Dark mode | SharedPreferences |
| Selected language | SharedPreferences |
| Onboarding status | SharedPreferences |
| Recently viewed products | SharedPreferences or local database depending on size |
| Product catalog | SQLite/local database for substantial structured data |
| Downloaded invoices | File Storage |
| Authentication secrets | Secure storage solution |
Flutter Shopping App
|
+-- User Preferences
| ↓
| SharedPreferences
|
+-- Product Data
| ↓
| Local Database
|
+-- Downloaded Invoice
| ↓
| File Storage
|
+-- Sensitive Credentials
↓
Secure StorageLocal data storage is the process of saving application data on the user's device so it can be accessed later.
It is used for relatively small key-value data such as preferences, settings, flags, and simple application configuration.
Common supported types are int, double, bool, String, and List.
SQLite is appropriate when the application needs structured, queryable, and potentially larger amounts of local data.
File storage is useful when the application needs to save documents, text, JSON files, generated files, or other file-based content.
No. SharedPreferences is intended for simple key-value storage, while SQLite is designed for structured data and database queries.
Ordinary preference storage should not be treated as a secure credential store. Sensitive credentials require an appropriate secure-storage mechanism.
Offline storage allows an application to keep information locally so that previously stored data can be accessed when the network is unavailable.
JustAcademy Flutter Training Course
Register for Flutter Course Demo
