---
title: "MMKV vs AsyncStorage vs SQLite vs SecureStore: qué almacenamiento usar en React Native"
description: "MMKV, AsyncStorage, SQLite y SecureStore en React Native: cómo funciona cada uno, su velocidad, ejemplos de apps reales y cómo elegir el adecuado."
url: "https://arbabnaseer.com/es/articulos/almacenamiento-local-react-native-comparativa/"
lang: "es"
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: qué almacenamiento usar en React Native

> MMKV, AsyncStorage, SQLite y SecureStore en React Native: cómo funciona cada uno, su velocidad, ejemplos de apps reales y cómo elegir el adecuado.

Arbab Naseer · 2026-10-23 · https://arbabnaseer.com/es/articulos/almacenamiento-local-react-native-comparativa/

**Respuesta corta:** usa **MMKV** para valores pequeños que tu app lee y escribe todo el tiempo (ajustes, flags, JSON en caché, estado persistido), **SQLite** cuando tus datos tienen tablas, relaciones o necesitan búsquedas y filtros, **SecureStore o Keychain** para tokens y cualquier cosa secreta, y **AsyncStorage** solo para unos pocos valores pequeños cuando la velocidad no importa o no puedes añadir código nativo. La mayoría de las apps en producción acaban usando dos o tres a la vez.

En la red social deportiva en la que trabajo, los datos locales pasan por MMKV y los datos del servidor por TanStack Query. En [ClientInfoTracker](https://arbabnaseer.com/es/proyectos/client-info-tracker-app-flutter/), una app de registros offline, todo vive en SQLite porque los datos son una tabla de verdad en la que la gente busca y filtra. Esta guía explica cómo funciona cada opción de almacenamiento, sobre qué está construida y a qué tipo de app se adapta.

## Las opciones de un vistazo

| Almacenamiento | Tipo | API | Construido sobre | Cifrado | Ideal para |
|---|---|---|---|---|---|
| AsyncStorage | Clave valor | Asíncrona (Promises) | SQLite en Android e iOS, IndexedDB en web | No | Unos pocos valores pequeños, prototipos rápidos |
| MMKV | Clave valor | Síncrona | C++ (Tencent MMKV), JSI y Nitro Modules | Opcional (AES) | Datos que se leen y escriben a menudo |
| SQLite | Base de datos relacional | Asíncrona o síncrona | Librería C de SQLite | Opcional (SQLCipher) | Tablas, relaciones, búsqueda, listas grandes |
| SecureStore / Keychain | Clave valor | Asíncrona (SecureStore también tiene versión síncrona) | Keychain de iOS, Android Keystore | Sí | Tokens, sesiones, contraseñas, claves |
| WatermelonDB | Base de datos reactiva | Asíncrona, observable | SQLite por debajo | A través de SQLite | Apps grandes offline first con sincronización |

Las versiones de este artículo son las que había en npm cuando lo escribí (octubre de 2026): `react-native-mmkv` 4.3.2, `@react-native-async-storage/async-storage` 3.1.1, `expo-sqlite` y `expo-secure-store` de Expo SDK 58, `react-native-keychain` 10.0.0.

## AsyncStorage: la opción sencilla por defecto

[AsyncStorage](https://react-native-async-storage.github.io/latest/) es el almacenamiento con el que empiezan casi todos los tutoriales. Antes venía dentro del propio React Native, luego pasó a un paquete de la comunidad, y sigue siendo la opción "por defecto" que conocen muchos desarrolladores.

**Cómo funciona:** llamas a una función de JavaScript, te devuelve una Promise y un módulo nativo hace la lectura o escritura real en segundo plano. La versión 3 reescribió la parte nativa: en Android, iOS y macOS los datos ahora viven en SQLite, y en la web usa IndexedDB. Solo guarda strings, así que los objetos pasan por `JSON.stringify` y `JSON.parse`. Nada va cifrado.

La versión 3 además funciona por instancias. Creas un almacenamiento con nombre en lugar de usar un objeto global:

```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' o null

// Las llamadas por lotes son mucho más baratas que un bucle de llamadas sueltas
await storage.setMany({ theme: 'dark', language: 'en' });
```

El import por defecto (`import AsyncStorage from ...`) sigue apuntando al antiguo almacenamiento de la v2, así que las apps existentes conservan sus datos al actualizar. La [guía de migración](https://github.com/react-native-async-storage/async-storage/blob/main/docs/migration-to-3.md) explica los cambios.

**Usa AsyncStorage cuando:**

- Guardas un puñado de valores pequeños, como "el usuario ya vio el onboarding" o el tema elegido.
- Estás prototipando y todavía no quieres pensar en el almacenamiento.
- Una librería que usas espera una interfaz asíncrona de `getItem` y `setItem` y no tienes motivo para cambiarla.

**Evítalo cuando** lees valores en cada render o al arrancar en una ruta crítica, o cuando los datos son grandes. Cada llamada es un viaje de ida y vuelta a través de una Promise, y eso se acumula rápido.

## MMKV: el almacenamiento clave valor más rápido

[MMKV](https://github.com/Tencent/MMKV) es un framework de almacenamiento clave valor escrito en C++ por el equipo de WeChat en Tencent. [react-native-mmkv](https://github.com/mrousavy/react-native-mmkv), mantenido por Marc Rousavy y Margelo, lo lleva a React Native.

**Cómo funciona:** MMKV proyecta su archivo directamente en memoria con `mmap` y codifica los valores con protobuf. Cuando escribes, el cambio llega a la memoria y el sistema operativo lo vuelca al disco, así que en JavaScript nunca esperas a una escritura en disco. El binding de React Native habla con C++ a través de JSI (la versión 4 es un [Nitro Module](https://nitro.margelo.com)), sin bridge y sin Promises. Todas las llamadas son síncronas:

```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
```

Guarda directamente strings, números, booleanos y `ArrayBuffer`s, admite varias instancias aisladas (por ejemplo una por cada usuario que inicia sesión), cifrado AES opcional y hooks de React como `useMMKVString`.

### ¿Cuánto más rápido es MMKV?

El proyecto [StorageBenchmark](https://github.com/mrousavy/StorageBenchmark) lee un valor 1000 veces con cada librería de almacenamiento. Estos son sus resultados publicados:

<figure class="bar-chart">
<figcaption>Tiempo para leer un valor 1000 veces (milisegundos, menos es más rápido)</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">Fuente: <a href="https://github.com/mrousavy/StorageBenchmark">mrousavy/StorageBenchmark</a>, iPhone 11 Pro, Hermes, build de depuración.</p>
</figure>

Eso hace que MMKV sea unas **20 veces más rápido** que AsyncStorage en lecturas, y unas 4 veces más rápido que la siguiente mejor opción. El README de MMKV lo redondea a "~30x". Ten en cuenta que el benchmark es de la época de React Native 0.68 y usó AsyncStorage antes de su reescritura en la v3, así que toma la proporción exacta como una referencia, no como una promesa. El orden no ha cambiado en ninguna prueba que yo haya visto. Profundizo en la velocidad, y en cómo medirla en tu propia app, en [cómo hacer rápido el almacenamiento local en React Native](https://arbabnaseer.com/es/articulos/almacenamiento-local-rapido-react-native-mmkv/).

**Usa MMKV cuando tu app lee y escribe a menudo:**

- **Apps sociales y de contenido:** la última publicación vista, los filtros del feed, el texto de un borrador, los usuarios silenciados, los ajustes de reproducción automática. Así lo uso en Social.
- **Apps de chat:** contadores de no leídos, borradores por conversación, la marca de tiempo de la última sincronización.
- **E-commerce:** el carrito, los productos vistos recientemente, la moneda seleccionada.
- **Cualquier app con estado persistido:** stores de Zustand, Redux o Jotai, y la caché de TanStack Query, para que la app se abra con datos ya en pantalla.

**Lo que debes saber:** react-native-mmkv 4 necesita React Native 0.76 o superior y código nativo, así que no funciona en Expo Go. Necesitas un development build, que explico en [Expo Go vs development builds](https://arbabnaseer.com/es/articulos/expo-go-vs-build-de-desarrollo/). MMKV mantiene sus datos en memoria, así que no es el sitio para miles de registros ni para archivos grandes.

## SQLite: cuando tus datos tienen tablas y relaciones

[SQLite](https://www.sqlite.org/) es una base de datos SQL completa en un único archivo. Es el motor de base de datos más usado del mundo, y todos los iPhone y móviles Android ya lo traen.

**Cómo funciona:** la librería C de SQLite se ejecuta dentro de tu app. Creas tablas, añades índices y lanzas consultas SQL. La base de datos solo carga las filas que necesita una consulta, así que maneja decenas de miles de registros sin cargarlo todo en la memoria de JavaScript. En React Native lo usas a través de un binding:

- [expo-sqlite](https://docs.expo.dev/versions/latest/sdk/sqlite/): el paquete oficial de Expo, funciona en Expo Go, tiene API asíncrona y síncrona y cifrado opcional con SQLCipher.
- [op-sqlite](https://op-engineering.github.io/op-sqlite/): un binding JSI centrado en la velocidad pura, con plugins de SQLCipher, búsqueda de texto completo FTS5 y sqlite-vec.
- [WatermelonDB](https://watermelondb.dev/docs): una base de datos reactiva sobre SQLite. Carga los registros de forma diferida, vuelve a renderizar los componentes cuando cambian los datos y tiene un protocolo de sincronización con tu backend.

Un ejemplo pequeño con 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
);
```

Prueba a escribir esa consulta de "bebidas con poco stock, ordenadas" con un almacenamiento clave valor. Tendrías que cargar todos los productos en memoria, parsear el JSON y filtrarlo en JavaScript. SQLite lo hace con un índice en unos pocos milisegundos.

**Usa SQLite cuando:**

- **Apps de negocio offline first:** punto de venta, inventario, pedidos, facturas, fichas de clientes. Mi app [ClientInfoTracker](https://arbabnaseer.com/es/proyectos/client-info-tracker-app-flutter/) está hecha así (en Flutter con sqflite, pero la idea es idéntica en React Native).
- **Apps de notas, diarios, tareas y gastos** en las que la gente busca, ordena y filtra.
- **Cualquier cosa con relaciones:** pedidos que pertenecen a clientes, mensajes que pertenecen a conversaciones.
- **Listas grandes** que recorres por páginas en lugar de cargarlas de golpe.

**Evítalo para** un puñado de ajustes. Crear tablas y escribir migraciones para tres flags es excesivo; MMKV hace ese trabajo mejor.

## Almacenamiento seguro: tokens, sesiones y secretos

Ni AsyncStorage ni MMKV sin cifrar son un sitio seguro para un token de autenticación. Sus archivos están protegidos por el sandbox de la app, pero en un móvil rooteado o con jailbreak, o desde una copia de seguridad del dispositivo sin cifrar, se pueden leer como texto plano.

**Cómo funciona:** las librerías de almacenamiento seguro entregan tu valor a la bóveda del propio sistema operativo. En iOS es el [Keychain](https://developer.apple.com/documentation/security/keychain_services). En Android el valor se cifra con una clave que vive en el [Android Keystore](https://developer.android.com/privacy-and-security/keystore?hl=es), que puede estar respaldado por hardware dedicado, así que la clave nunca entra en la memoria de tu app.

- [expo-secure-store](https://docs.expo.dev/versions/latest/sdk/securestore/): API clave valor sencilla, funciona en Expo Go, protección biométrica opcional.
- [react-native-keychain](https://oblador.github.io/react-native-keychain): más control sobre las reglas de acceso, la biometría y los niveles de seguridad, popular en apps de React Native sin Expo.

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

await SecureStore.setItemAsync('refreshToken', token);
const saved = await SecureStore.getItemAsync('refreshToken');
await SecureStore.deleteItemAsync('refreshToken'); // al cerrar sesión
```

**Usa almacenamiento seguro para:** access tokens y refresh tokens, ids de sesión, el PIN o la contraseña de un usuario (si de verdad tienes que guardarlos), API keys por usuario y la clave de cifrado de una base de datos MMKV o SQLite cifrada.

**Evítalo para** datos grandes o que se leen con frecuencia. Es más lento que MMKV, y la documentación de Expo avisa de que algunas versiones de iOS rechazan valores de más de unos 2048 bytes. Guarda un token, no un perfil de usuario entero. Explico la configuración completa, incluido lo que pasa al cerrar sesión y al reinstalar, en [cómo guardar tokens de autenticación de forma segura en React Native](https://arbabnaseer.com/es/articulos/guardar-tokens-de-forma-segura-react-native/).

## Cómo decidir qué almacenamiento necesita tu app

Hazte cuatro preguntas sobre cada dato, no sobre la app en conjunto:

1. **¿Es secreto?** Si filtrarlo permitiría a alguien hacerse pasar por el usuario, va en SecureStore o Keychain. Aquí termina la decisión.
2. **¿Tiene estructura?** Si necesitas buscar, ordenar, filtrar, cruzar o paginar, usa SQLite (o WatermelonDB para datos grandes sincronizados).
3. **¿Se lee o escribe a menudo, o se necesita al arrancar?** Usa MMKV. Las lecturas síncronas evitan el parpadeo de carga al abrir la app.
4. **¿Nada de lo anterior, y solo son unos pocos valores?** AsyncStorage sirve, aunque MMKV no te cuesta nada extra si ya está instalado.

| Si tu app necesita... | Usa |
|---|---|
| Leer y escribir valores pequeños muy rápido | MMKV |
| Abrirse con el último estado ya en pantalla | MMKV (persiste tu store o la caché de consultas) |
| Guardar unos flags en un prototipo con Expo Go | AsyncStorage |
| Mantener cientos o miles de registros offline | SQLite |
| Buscar, filtrar y ordenar datos locales | SQLite |
| Sincronizar una base de datos local grande con un servidor | WatermelonDB |
| Proteger tokens de inicio de sesión y sesiones | SecureStore o Keychain |
| Guardar fotos, PDF u otros archivos grandes | El sistema de archivos (`expo-file-system`), con la ruta en SQLite o MMKV |

## Usar más de un almacenamiento a la vez

No hay ninguna regla que diga que cada app tiene un solo almacenamiento. Esta es una configuración que uso a menudo:

- **SecureStore:** el refresh token y la clave de cifrado de MMKV.
- **MMKV:** preferencias del usuario, feature flags, borradores y la caché persistida de TanStack Query.
- **SQLite:** solo si la app tiene datos offline de verdad, como pedidos o registros.

Cada herramienta hace el trabajo para el que es buena, y ninguna se fuerza más allá de eso.

## Preguntas frecuentes

### ¿Es MMKV mejor que AsyncStorage?

En velocidad, sí. MMKV es síncrono y unas 20 veces más rápido en lecturas según el StorageBenchmark publicado. AsyncStorage sigue teniendo sentido cuando no puedes añadir código nativo, por ejemplo dentro de Expo Go, o cuando solo guardas un par de valores y la velocidad no importa.

### ¿Puedo usar MMKV en Expo?

Sí, pero no en Expo Go. react-native-mmkv contiene código nativo, así que lo instalas con `npx expo install react-native-mmkv react-native-nitro-modules` y ejecutas tu app en un development build creado con `npx expo run:android`, `npx expo run:ios` o EAS Build.

### ¿AsyncStorage está obsoleto?

No. AsyncStorage lo mantiene la comunidad, y la versión 3 fue una gran reescritura con backend en SQLite e instancias con nombre. Hace años que salió del núcleo de React Native, y de ahí viene la idea de que está "obsoleto".

### ¿Debo guardar tokens JWT en AsyncStorage o en MMKV?

No. Guarda los tokens en expo-secure-store o react-native-keychain, que usan el Keychain de iOS y el Android Keystore. Si necesitas acceso rápido durante la sesión, mantén el token en memoria después de leerlo una vez.

### ¿Cuándo debo usar SQLite en lugar de MMKV en React Native?

Usa SQLite cuando los datos son una lista de registros que necesitas consultar: buscar, filtrar, ordenar, paginar o relacionar con otros registros. Usa MMKV para valores individuales que lees por clave. Una buena señal de que elegiste mal es guardar un array JSON enorme en MMKV y filtrarlo en JavaScript.

### ¿SQLite es lento en React Native?

No si se usa bien. Los bindings modernos como expo-sqlite y op-sqlite ejecutan las consultas en la parte nativa, y con índices y transacciones una consulta sobre miles de filas suele terminar en unos pocos milisegundos. Es más lento que MMKV para buscar una sola clave, porque hace más trabajo.

---

¿Quieres ver la parte de la velocidad en detalle? Lee [cómo hacer rápido el almacenamiento local en React Native](https://arbabnaseer.com/es/articulos/almacenamiento-local-rapido-react-native-mmkv/). Si necesitas una app de React Native construida con el almacenamiento adecuado desde el primer día, [escríbeme](/es/contacto/).
