---
title: "MMKV vs AsyncStorage vs SQLite vs SecureStore : quel stockage choisir en React Native"
description: "MMKV, AsyncStorage, SQLite et SecureStore en React Native : fonctionnement, vitesse, exemples d'applications réelles et méthode simple pour bien choisir."
url: "https://arbabnaseer.com/fr/articles/comparatif-stockage-local-react-native/"
lang: "fr"
author: "Arbab Naseer"
datePublished: "2026-10-23T00:00:00+05:00"
dateModified: "2026-10-23T00:00:00+05:00"
tags: "React Native, Expo, MMKV, SQLite, TypeScript, Performance"
---

# MMKV vs AsyncStorage vs SQLite vs SecureStore : quel stockage choisir en React Native

> MMKV, AsyncStorage, SQLite et SecureStore en React Native : fonctionnement, vitesse, exemples d'applications réelles et méthode simple pour bien choisir.

Arbab Naseer · 2026-10-23 · https://arbabnaseer.com/fr/articles/comparatif-stockage-local-react-native/

**Réponse courte :** utilisez **MMKV** pour les petites valeurs que votre application lit et écrit en permanence (réglages, flags, JSON en cache, état persisté), **SQLite** quand vos données ont des tables, des relations ou demandent de la recherche et des filtres, **SecureStore ou Keychain** pour les tokens et tout ce qui est secret, et **AsyncStorage** seulement pour quelques petites valeurs quand la vitesse ne compte pas ou que vous ne pouvez pas ajouter de code natif. La plupart des applications en production finissent par en combiner deux ou trois.

Dans le réseau social sportif sur lequel je travaille, les données locales passent par MMKV et les données serveur par TanStack Query. Dans [ClientInfoTracker](https://arbabnaseer.com/fr/projets/client-info-tracker-application-flutter/), une application de fiches qui fonctionne hors ligne, tout est dans SQLite, parce que les données forment une vraie table que les utilisateurs recherchent et filtrent. Ce guide explique comment fonctionne chaque solution de stockage, sur quoi elle repose et à quel type d'application elle convient.

## Les options en un coup d'œil

| Stockage | Type | API | Repose sur | Chiffré | Idéal pour |
|---|---|---|---|---|---|
| AsyncStorage | Clé-valeur | Asynchrone (Promises) | SQLite sur Android et iOS, IndexedDB sur le web | Non | Quelques petites valeurs, prototypes rapides |
| MMKV | Clé-valeur | Synchrone | C++ (Tencent MMKV), JSI et Nitro Modules | En option (AES) | Données chaudes lues et écrites souvent |
| SQLite | Base de données relationnelle | Asynchrone ou synchrone | Bibliothèque C SQLite | En option (SQLCipher) | Tables, relations, recherche, longues listes |
| SecureStore / Keychain | Clé-valeur | Asynchrone (synchrone aussi disponible dans SecureStore) | Keychain iOS, Android Keystore | Oui | Tokens, sessions, mots de passe, clés |
| WatermelonDB | Base de données réactive | Asynchrone, observable | SQLite en dessous | Via SQLite | Grosses applications offline first avec synchronisation |

Les versions citées dans cet article sont celles publiées sur npm au moment où je l'ai écrit (octobre 2026) : `react-native-mmkv` 4.3.2, `@react-native-async-storage/async-storage` 3.1.1, `expo-sqlite` et `expo-secure-store` de l'Expo SDK 58, `react-native-keychain` 10.0.0.

## AsyncStorage : le choix par défaut, simple

[AsyncStorage](https://react-native-async-storage.github.io/latest/) est le stockage par lequel commencent la plupart des tutoriels. Il était autrefois inclus dans React Native, puis il est passé dans un package communautaire, et il reste le stockage « par défaut » que beaucoup de développeurs connaissent.

**Comment il fonctionne :** vous appelez une fonction JavaScript, elle renvoie une Promise, et un module natif fait la vraie lecture ou écriture en arrière-plan. La version 3 a réécrit toute la partie native : sur Android, iOS et macOS, les données sont désormais dans SQLite, et sur le web dans IndexedDB. Il ne stocke que des chaînes, donc les objets passent par `JSON.stringify` et `JSON.parse`. Rien n'est chiffré.

La version 3 fonctionne aussi par instances. Vous créez un stockage nommé au lieu d'utiliser un objet global unique :

```ts
import { createAsyncStorage } from '@react-native-async-storage/async-storage';

const storage = createAsyncStorage('app');

await storage.setItem('onboardingSeen', 'true');
const seen = await storage.getItem('onboardingSeen'); // 'true' ou null

// Les appels groupés coûtent beaucoup moins cher qu'une boucle d'appels unitaires
await storage.setMany({ theme: 'dark', language: 'en' });
```

L'import par défaut (`import AsyncStorage from ...`) pointe toujours vers l'ancien stockage v2, donc les applications existantes gardent leurs données après la mise à jour. Le [guide de migration](https://github.com/react-native-async-storage/async-storage/blob/main/docs/migration-to-3.md) détaille les changements.

**Utilisez AsyncStorage quand :**

- Vous stockez une poignée de petites valeurs, comme « l'utilisateur a-t-il vu l'onboarding » ou le thème choisi.
- Vous faites un prototype et ne voulez pas encore vous soucier du stockage.
- Une bibliothèque que vous utilisez attend une interface asynchrone `getItem` et `setItem` et vous n'avez aucune raison de la remplacer.

**Évitez-le quand** vous lisez des valeurs à chaque rendu ou au démarrage, dans un chemin critique, ou quand les données sont volumineuses. Chaque appel fait un aller-retour par une Promise, et ça s'accumule vite.

## MMKV : le stockage clé-valeur le plus rapide

[MMKV](https://github.com/Tencent/MMKV) est un framework de stockage clé-valeur écrit en C++ par l'équipe WeChat de Tencent. [react-native-mmkv](https://github.com/mrousavy/react-native-mmkv), maintenu par Marc Rousavy et Margelo, l'apporte à React Native.

**Comment il fonctionne :** MMKV projette son fichier directement en mémoire avec `mmap` et encode les valeurs avec protobuf. Quand vous écrivez, la modification arrive en mémoire et le système d'exploitation la reporte sur le disque, donc vous n'attendez jamais une écriture disque côté JavaScript. Le binding React Native communique avec le C++ via JSI (la version 4 est un [Nitro Module](https://nitro.margelo.com)), sans bridge et sans Promises. Chaque appel est synchrone :

```ts
import { createMMKV } from 'react-native-mmkv';

export const storage = createMMKV();

storage.set('user.name', 'Arbab');
storage.set('feed.lastSeenId', 1042);
storage.set('settings.autoplay', true);

const name = storage.getString('user.name'); // 'Arbab'
const autoplay = storage.getBoolean('settings.autoplay'); // true
```

Il stocke directement des chaînes, des nombres, des booléens et des `ArrayBuffer`, gère plusieurs instances isolées (par exemple une par utilisateur connecté), propose un chiffrement AES en option et des hooks React comme `useMMKVString`.

### MMKV est-il vraiment plus rapide ?

Le projet [StorageBenchmark](https://github.com/mrousavy/StorageBenchmark) lit une même valeur 1000 fois avec chaque bibliothèque de stockage. Voici ses résultats publiés :

<figure class="bar-chart">
<figcaption>Temps pour lire une valeur 1000 fois (en millisecondes, plus c'est court, plus c'est rapide)</figcaption>
<div class="bar-chart-row is-best" style="--bar: 5%"><span>MMKV</span><span class="bar-chart-track"><span class="bar-chart-fill"></span></span><span class="bar-chart-value">12 ms</span></div>
<div class="bar-chart-row" style="--bar: 22%"><span>WatermelonDB</span><span class="bar-chart-track"><span class="bar-chart-fill"></span></span><span class="bar-chart-value">53 ms</span></div>
<div class="bar-chart-row" style="--bar: 33%"><span>Realm</span><span class="bar-chart-track"><span class="bar-chart-fill"></span></span><span class="bar-chart-value">81 ms</span></div>
<div class="bar-chart-row" style="--bar: 34%"><span>SQLite (quick-sqlite)</span><span class="bar-chart-track"><span class="bar-chart-fill"></span></span><span class="bar-chart-value">82 ms</span></div>
<div class="bar-chart-row is-worst" style="--bar: 100%"><span>AsyncStorage</span><span class="bar-chart-track"><span class="bar-chart-fill"></span></span><span class="bar-chart-value">242 ms</span></div>
<p class="bar-chart-note">Source : <a href="https://github.com/mrousavy/StorageBenchmark">mrousavy/StorageBenchmark</a>, iPhone 11 Pro, Hermes, build de debug.</p>
</figure>

MMKV est donc environ **20 fois plus rapide** qu'AsyncStorage en lecture, et à peu près 4 fois plus rapide que la meilleure option suivante. Le README de MMKV arrondit à « ~30x ». Gardez en tête que ce benchmark date de l'époque de React Native 0.68 et utilisait AsyncStorage avant sa réécriture en v3 : prenez le ratio exact comme un ordre de grandeur, pas comme une promesse. Le classement, lui, n'a changé dans aucun test que j'ai vu. J'entre davantage dans le détail de la vitesse, et de la façon de la mesurer dans votre propre application, dans [comment rendre le stockage local rapide en React Native](https://arbabnaseer.com/fr/articles/stockage-local-rapide-react-native-mmkv/).

**Utilisez MMKV quand votre application lit et écrit souvent :**

- **Applications sociales et de contenu :** le dernier post vu, les filtres du fil, les brouillons, les utilisateurs masqués, les réglages de lecture automatique. C'est ainsi que je l'utilise dans Social.
- **Applications de messagerie :** compteurs de non lus, brouillons par conversation, horodatage de la dernière synchronisation.
- **E-commerce :** le panier, les produits consultés récemment, la devise choisie.
- **Toute application avec un état persisté :** stores Zustand, Redux ou Jotai, et le cache de TanStack Query, pour que l'application s'ouvre avec des données déjà à l'écran.

**À savoir :** react-native-mmkv 4 demande React Native 0.76 ou plus récent et contient du code natif, donc il ne tourne pas dans Expo Go. Il vous faut un development build, ce que j'explique dans [Expo Go vs development builds](https://arbabnaseer.com/fr/articles/expo-go-vs-build-de-developpement/). MMKV garde ses données en mémoire : ce n'est pas l'endroit pour des milliers d'enregistrements ou de gros fichiers.

## SQLite : quand vos données ont des tables et des relations

[SQLite](https://www.sqlite.org/) est une base de données SQL complète dans un seul fichier. C'est le moteur de base de données le plus utilisé au monde, et chaque iPhone et chaque téléphone Android l'embarque déjà.

**Comment il fonctionne :** la bibliothèque C SQLite tourne à l'intérieur de votre application. Vous créez des tables, ajoutez des index et lancez des requêtes SQL. La base ne charge que les lignes dont une requête a besoin, donc elle gère des dizaines de milliers d'enregistrements sans tout charger dans la mémoire JavaScript. En React Native, vous l'utilisez via un binding :

- [expo-sqlite](https://docs.expo.dev/versions/latest/sdk/sqlite/) : le package officiel d'Expo, fonctionne dans Expo Go, avec des API asynchrones et synchrones et un chiffrement SQLCipher en option.
- [op-sqlite](https://op-engineering.github.io/op-sqlite/) : un binding JSI axé sur la vitesse brute, avec SQLCipher, la recherche plein texte FTS5 et les plugins sqlite-vec.
- [WatermelonDB](https://watermelondb.dev/docs) : une base de données réactive au-dessus de SQLite. Elle charge les enregistrements à la demande, refait le rendu des composants quand les données changent et propose un protocole de synchronisation avec votre backend.

Un petit exemple avec expo-sqlite :

```ts
import * as SQLite from 'expo-sqlite';

const db = await SQLite.openDatabaseAsync('shop.db');

await db.execAsync(`
  PRAGMA journal_mode = WAL;
  CREATE TABLE IF NOT EXISTS products (
    id INTEGER PRIMARY KEY NOT NULL,
    name TEXT NOT NULL,
    category TEXT NOT NULL,
    stock INTEGER NOT NULL
  );
  CREATE INDEX IF NOT EXISTS idx_products_category ON products (category);
`);

await db.runAsync('INSERT INTO products (name, category, stock) VALUES (?, ?, ?)', 'Tea', 'drinks', 40);

const lowStock = await db.getAllAsync<{ name: string; stock: number }>(
  'SELECT name, stock FROM products WHERE category = ? AND stock < ? ORDER BY stock',
  'drinks',
  10
);
```

Essayez d'écrire cette requête « boissons en stock faible, triées » avec un stockage clé-valeur. Il faudrait charger tous les produits en mémoire, parser le JSON et filtrer en JavaScript. SQLite le fait avec un index en quelques millisecondes.

**Utilisez SQLite pour :**

- **Les applications métier offline first :** caisse, inventaire, commandes, factures, fiches clients. Mon application [ClientInfoTracker](https://arbabnaseer.com/fr/projets/client-info-tracker-application-flutter/) est construite ainsi (en Flutter avec sqflite, mais l'idée est identique en React Native).
- **Les applications de notes, de journal, de tâches et de dépenses** où l'on recherche, trie et filtre.
- **Tout ce qui a des relations :** des commandes qui appartiennent à des clients, des messages qui appartiennent à des conversations.
- **Les longues listes** que vous parcourez page par page au lieu de tout charger d'un coup.

**Évitez-le pour** une poignée de réglages. Créer des tables et écrire des migrations pour trois flags, c'est disproportionné ; MMKV fait ce travail mieux.

## Stockage sécurisé : tokens, sessions et secrets

Ni AsyncStorage ni MMKV sans chiffrement ne sont un endroit sûr pour un token d'authentification. Leurs fichiers sont protégés par le sandbox de l'application, mais sur un téléphone rooté ou jailbreaké, ou depuis une sauvegarde non chiffrée de l'appareil, ils se lisent en clair.

**Comment il fonctionne :** les bibliothèques de stockage sécurisé confient votre valeur au coffre-fort du système d'exploitation. Sur iOS, c'est le [Keychain](https://developer.apple.com/documentation/security/keychain_services). Sur Android, la valeur est chiffrée avec une clé qui se trouve dans l'[Android Keystore](https://developer.android.com/privacy-and-security/keystore?hl=fr), qui peut s'appuyer sur un composant matériel dédié, si bien que la clé n'entre jamais dans la mémoire de votre application.

- [expo-secure-store](https://docs.expo.dev/versions/latest/sdk/securestore/) : API clé-valeur simple, fonctionne dans Expo Go, protection biométrique en option.
- [react-native-keychain](https://oblador.github.io/react-native-keychain) : plus de contrôle sur les règles d'accès, la biométrie et les niveaux de sécurité, très utilisé dans les applications React Native sans Expo.

```ts
import * as SecureStore from 'expo-secure-store';

await SecureStore.setItemAsync('refreshToken', token);
const saved = await SecureStore.getItemAsync('refreshToken');
await SecureStore.deleteItemAsync('refreshToken'); // à la déconnexion
```

**Utilisez le stockage sécurisé pour :** les access tokens et refresh tokens, les identifiants de session, le PIN ou le mot de passe d'un utilisateur (si vous devez vraiment le stocker), les clés d'API propres à chaque utilisateur, et la clé de chiffrement d'une base MMKV ou SQLite chiffrée.

**Évitez-le pour** les données volumineuses ou lues très souvent. Il est plus lent que MMKV, et la documentation Expo prévient que certaines versions d'iOS refusent les valeurs au-delà d'environ 2048 octets. Stockez un token, pas un profil utilisateur entier. Je détaille toute la mise en place, y compris ce qui se passe à la déconnexion et à la réinstallation, dans [comment stocker des tokens d'authentification de façon sécurisée en React Native](https://arbabnaseer.com/fr/articles/stocker-tokens-securise-react-native/).

## Comment choisir le stockage dont votre application a besoin

Posez quatre questions pour chaque donnée, pas pour l'application dans son ensemble :

1. **Est-ce secret ?** Si une fuite permettait à quelqu'un d'agir à la place de l'utilisateur, la donnée va dans SecureStore ou Keychain. Inutile d'aller plus loin.
2. **A-t-elle une structure ?** Si vous devez la rechercher, la trier, la filtrer, faire des jointures ou la paginer, utilisez SQLite (ou WatermelonDB pour de gros volumes synchronisés).
3. **Est-elle lue ou écrite souvent, ou nécessaire au démarrage ?** Utilisez MMKV. Les lectures synchrones évitent le flash de chargement au lancement.
4. **Rien de tout ça, et seulement quelques valeurs ?** AsyncStorage suffit, même si MMKV ne vous coûte rien de plus s'il est déjà installé.

| Si votre application doit... | Utilisez |
|---|---|
| Lire et écrire de petites valeurs très vite | MMKV |
| S'ouvrir avec le dernier état déjà à l'écran | MMKV (persistez votre store ou le cache de requêtes) |
| Stocker quelques flags dans un prototype Expo Go | AsyncStorage |
| Garder des centaines ou des milliers d'enregistrements hors ligne | SQLite |
| Rechercher, filtrer et trier des données locales | SQLite |
| Synchroniser une grosse base locale avec un serveur | WatermelonDB |
| Protéger les tokens de connexion et les sessions | SecureStore ou Keychain |
| Stocker des photos, des PDF ou d'autres gros fichiers | Le système de fichiers (`expo-file-system`), avec le chemin dans SQLite ou MMKV |

## Utiliser plusieurs stockages ensemble

Aucune règle n'impose un seul stockage par application. Voici une configuration que j'utilise souvent :

- **SecureStore :** le refresh token et la clé de chiffrement MMKV.
- **MMKV :** les préférences utilisateur, les feature flags, les brouillons et le cache TanStack Query persisté.
- **SQLite :** seulement si l'application a de vraies données hors ligne, comme des commandes ou des fiches.

Chaque outil fait le travail pour lequel il est bon, et aucun n'est poussé au-delà.

## Questions fréquentes

### MMKV est-il meilleur qu'AsyncStorage ?

Pour la vitesse, oui. MMKV est synchrone et environ 20 fois plus rapide en lecture dans les résultats publiés de StorageBenchmark. AsyncStorage reste pertinent quand vous ne pouvez pas ajouter de code natif, par exemple dans Expo Go, ou quand vous ne stockez que deux ou trois valeurs et que la vitesse ne compte pas.

### Peut-on utiliser MMKV avec Expo ?

Oui, mais pas dans Expo Go. react-native-mmkv contient du code natif, donc vous l'installez avec `npx expo install react-native-mmkv react-native-nitro-modules` et vous lancez votre application dans un development build créé avec `npx expo run:android`, `npx expo run:ios` ou EAS Build.

### AsyncStorage est-il déprécié ?

Non. AsyncStorage est maintenu par la communauté et la version 3 est une grosse réécriture avec un backend SQLite et des instances nommées. Il a été retiré du cœur de React Native il y a des années, d'où l'idée qu'il serait « déprécié ».

### Faut-il stocker les tokens JWT dans AsyncStorage ou MMKV ?

Non. Stockez les tokens dans expo-secure-store ou react-native-keychain, qui utilisent le Keychain iOS et l'Android Keystore. Si vous avez besoin d'un accès rapide pendant une session, gardez le token en mémoire après l'avoir lu une fois.

### Quand utiliser SQLite plutôt que MMKV en React Native ?

Utilisez SQLite quand les données sont une liste d'enregistrements à interroger : recherche, filtre, tri, pagination ou relations avec d'autres enregistrements. Utilisez MMKV pour des valeurs isolées que vous lisez par clé. Un bon signe que vous vous êtes trompé : stocker un gros tableau JSON dans MMKV et le filtrer en JavaScript.

### SQLite est-il lent en React Native ?

Pas s'il est bien utilisé. Les bindings modernes comme expo-sqlite et op-sqlite exécutent les requêtes côté natif, et avec des index et des transactions, une requête sur des milliers de lignes se termine en général en quelques millisecondes. Il est plus lent que MMKV pour une simple lecture par clé, parce qu'il fait plus de travail.

---

Vous voulez le détail côté performance ? Lisez [comment rendre le stockage local rapide en React Native](https://arbabnaseer.com/fr/articles/stockage-local-rapide-react-native-mmkv/). Si vous avez besoin d'une application React Native construite avec le bon stockage dès le premier jour, [contactez-moi](/fr/contact/).
