How do you persist data locally in Flutter?

Question

Accepted Answer

Apps often need to **store data locally** on the device — user preferences, cached data, offline content. Flutter offers several options — **shared_preferences** (key-value), **SQLite** (relational), and others — each suited to different needs.

## Local storage options

```text
SHARED_PREFERENCES → simple KEY-VALUE storage (settings, flags, small data):
  → store primitives (strings, ints, bools) — like a simple persistent map
  → for: user preferences, tokens, simple flags (NOT large/structured data)
SQLITE (sqflite) → a full relational DATABASE on the device:
  → tables, SQL queries — for STRUCTURED, larger data; complex queries; relationships
HIVE / ISAR → fast NoSQL local databases (key-value/object stores) — popular, fast,
  Dart-native (no SQL); good for structured local data
FILE storage → read/write files directly (path_provider for directories)
SECURE storage → flutter_secure_storage for SENSITIVE data (tokens, credentials) —
  encrypted (keychain/keystore)
```

## shared_preferences example

```dart
final prefs = await SharedPreferences.getInstance();
await prefs.setString('username', 'Ann');      // store
final name = prefs.getString('username');        // retrieve
await prefs.setBool('darkMode', true);
```

## Choosing the right option

```text
Simple settings/flags → shared_preferences (easy key-value)
Structured/large data, queries → SQLite (sqflite) or Hive/Isar
Sensitive data (tokens, passwords) → flutter_secure_storage (ENCRYPTED — don't put
  secrets in shared_preferences, which is NOT secure)
Files → file storage (path_provider)
→ Match the storage to the data's size, structure, and sensitivity.
```

## Why it matters

Understanding how to persist data locally is valuable because **apps commonly need to store data on the device** — user preferences, cached data, offline content, authentication tokens — so it's useful practical knowledge for building real apps.

Local persistence is a near-universal need (remembering settings, caching for offline use, storing session data), and Flutter offers several options suited to different needs.

Understanding the **options** — **shared_preferences** (simple key-value storage for settings, flags, and small data), **SQLite/sqflite** (a full relational database for structured, larger data with queries and relationships), **Hive/Isar** (fast Dart-native NoSQL databases popular for structured local data), file storage, and **secure storage** (`flutter_secure_storage` for sensitive data) — and **when to use each** is the key knowledge.

Choosing the **right option** matters: shared_preferences for simple settings, SQLite or Hive/Isar for structured/large data, file storage for files, and crucially **secure storage for sensitive data** like tokens and credentials (which must be encrypted via the platform keychain/keystore — an important security point, since **shared_preferences is not secure and shouldn't hold secrets**, a common mistake).

Matching the storage to the data's size, structure, and sensitivity reflects sound decisions and avoids problems (like using the wrong tool for the job or insecurely storing credentials).

Since apps commonly need local persistence (settings, caching, offline data, tokens) and Flutter offers several options for different needs, and since understanding them and choosing appropriately (especially using secure storage for sensitive data) is valuable for building real apps correctly, understanding local data persistence in Flutter is valuable, practically-relevant knowledge — a common need in real apps, important for both functionality (storing the right data the right way) and security (protecting sensitive data with secure storage), and a useful skill for building apps that remember state and work offline.