Firexport / Guías

Cómo exportar datos de Firestore a JSON

Realtime Database tiene un botón Exportar JSON en Firebase console. Firestore no. Hay tres formas prácticas de sacar documentos de Firestore como JSON, desde los resultados de una consulta hasta una colección entera con sus subcolecciones.

Actualizado el 24 de septiembre de 2026. Firexport, la extensión del método 1, es nuestra. Los métodos 2 y 3 no la necesitan.

1. Exportar desde Firebase console con Firexport

La página de Firestore en Firebase console tiene un compilador de consultas (Query builder) que ejecuta una consulta y muestra los resultados en una tabla, pero nada con qué descargarlos. Firexport es una extensión gratuita de Chrome que agrega un botón Exportar junto a esos resultados.

1. Instala Firexport desde Chrome Web Store.
2. En Firebase console, abre Firestore Database y cambia de vista de panel (Panel view) a compilador de consultas (Query builder) (arriba a la derecha de la pestaña Datos).
3. Elige la colección en Alcance de la consulta (Query scope) y Ruta (Path), agrega filtros o un límite si quieres, y haz clic en Ejecutar (Run).
4. Abre el menú ⋮ junto al botón Exportar y elige Exportar a JSON. Firexport recorre todas las páginas de resultados y descarga un solo archivo JSON. (El botón Exportar en sí guarda CSV.)

El archivo es un arreglo JSON con un objeto por documento: una clave Document ID y luego los campos del documento. Los números, booleanos y null conservan sus tipos JSON, y los mapas y arreglos salen anidados. Lo que cambia entre la versión gratuita y Advanced son los valores que la consola solo muestra como texto:

Gratis: marcas de tiempo, geopuntos y referencias tal como los muestra la consola:

[
  {
    "Document ID": "2PomjkgoCISvwnlGrypP",
    "name": "firexport",
    "count": 1,
    "tags": ["dev", "export"],
    "settings": { "theme": "dark", "beta": true },
    "createdAt": "August 24, 2026 at 1:16:09 PM UTC+9",
    "location": "[37.5665° N, 126.978° E]",
    "owner": "/users/u1"
  }
]

Advanced (licencia de pago único): los mismos valores restaurados a partir de los datos que la consola ya cargó:

[
  {
    "Document ID": "2PomjkgoCISvwnlGrypP",
    "name": "firexport",
    "count": 1,
    "tags": ["dev", "export"],
    "settings": { "theme": "dark", "beta": true },
    "createdAt": "2026-08-24T04:16:09.012207Z",
    "location": { "latitude": 37.5665, "longitude": 126.978 },
    "owner": "projects/my-app/databases/(default)/documents/users/u1"
  }
]

En la versión gratuita, un mapa o arreglo cuyo texto en la consola no se puede volver a leer como JSON (uno que la consola cortó con “…”, por ejemplo) se queda como cadena. Advanced los escribe completos. En cualquier caso no hay que configurar ninguna clave de cuenta de servicio ni facturación: funciona en la sesión de la consola en la que ya iniciaste sesión, y el archivo se crea en tu navegador. Funciona en Chrome y otros navegadores basados en Chromium.

Exporta tu próxima consulta de Firestore como JSON desde la consola, sin scripts ni claves de cuenta de servicio.

Añadir a Chrome — gratis

2. Exportar con un script del Admin SDK

Un script corto de Node.js con el Firebase Admin SDK puede exportar una colección entera, y puede entrar en las subcolecciones, cosa que ninguno de los otros métodos hace. Necesita una cuenta que pueda leer Firestore: un Propietario o Editor del proyecto, o el rol Visualizador de Cloud Datastore.

1. Instala el SDK: npm install firebase-admin
2. Inicia sesión para obtener credenciales locales: gcloud auth application-default login. En un servidor, apunta GOOGLE_APPLICATION_CREDENTIALS a una clave de cuenta de servicio.
3. Guarda el script de abajo como export-to-json.mjs, reemplaza your-project-id y ejecuta node export-to-json.mjs users. Agrega --subcollections para incluir las subcolecciones de cada documento.

// Usage: node export-to-json.mjs users [--subcollections]   → writes users.json
import { writeFileSync } from 'node:fs';
import { initializeApp } from 'firebase-admin/app';
import {
  getFirestore,
  FieldPath,
  Timestamp,
  GeoPoint,
  DocumentReference,
} from 'firebase-admin/firestore';

initializeApp({ projectId: 'your-project-id' });
const db = getFirestore();
const [collection, flag] = process.argv.slice(2);
if (!collection) throw new Error('Usage: node export-to-json.mjs <collection> [--subcollections]');
const withSubcollections = flag === '--subcollections';

// Firestore types become JSON values: timestamps as ISO 8601, references as paths.
function plain(value) {
  if (value instanceof Timestamp) return value.toDate().toISOString();
  if (value instanceof DocumentReference) return value.path;
  if (value instanceof GeoPoint) return { latitude: value.latitude, longitude: value.longitude };
  if (value instanceof Uint8Array) return Buffer.from(value).toString('base64');
  if (Array.isArray(value)) return value.map(plain);
  if (value && typeof value === 'object') {
    return Object.fromEntries(Object.entries(value).map(([key, v]) => [key, plain(v)]));
  }
  return value;
}

// Read a collection 1,000 documents at a time. With --subcollections, each document also gets its
// subcollections under "__collections__", read the same way.
async function readCollection(ref) {
  const docs = [];
  let last;
  while (true) {
    let query = ref.orderBy(FieldPath.documentId()).limit(1000);
    if (last) query = query.startAfter(last);
    const page = await query.get();
    if (page.empty) break;
    for (const doc of page.docs) {
      const row = { documentId: doc.id, ...plain(doc.data()) };
      if (withSubcollections) {
        for (const sub of await doc.ref.listCollections()) {
          row.__collections__ ??= {};
          row.__collections__[sub.id] = await readCollection(sub);
        }
      }
      docs.push(row);
    }
    last = page.docs[page.docs.length - 1];
  }
  return docs;
}

const docs = await readCollection(db.collection(collection));
writeFileSync(`${collection}.json`, JSON.stringify(docs, null, 2));
console.log(`Wrote ${docs.length} documents to ${collection}.json`);

• Con --subcollections, cada documento que tenga subcolecciones recibe una clave __collections__ que las contiene, anidadas hasta donde lleguen. Encontrarlas cuesta una petición extra por documento, así que las colecciones grandes tardan más.
• Las subcolecciones bajo un documento que no existe por sí mismo (la consola muestra su ID en cursiva) no se alcanzan desde la colección padre. Expórtalas por grupo de colecciones.
• El script guarda todo en memoria antes de escribir el archivo. Para millones de documentos, usa el método 3.

3. Exportar con gcloud y BigQuery

La exportación administrada de Firestore escribe una copia de seguridad en Cloud Storage en el formato propio de Firestore, no en JSON. BigQuery puede cargar ese formato y volver a escribirlo como JSON. Es la vía para colecciones grandes, pero necesita la facturación habilitada (el plan Blaze) y permiso para ejecutar exportaciones y escribir en el bucket. La documentación de exportación e importación de Google lista los roles.

# 1. Export one collection. BigQuery only loads exports made with --collection-ids.
gcloud firestore export gs://YOUR_BUCKET/users-export --collection-ids=users

# 2. Load it into a BigQuery dataset in the same location as the bucket.
bq --location=US mk --dataset firestore_export
bq load --source_format=DATASTORE_BACKUP firestore_export.users \
  gs://YOUR_BUCKET/users-export/all_namespaces/kind_users/all_namespaces_kind_users.export_metadata

# 3. Write it out as newline-delimited JSON and download it.
bq extract --destination_format=NEWLINE_DELIMITED_JSON firestore_export.users gs://YOUR_BUCKET/users.json
gcloud storage cp gs://YOUR_BUCKET/users.json .

• El archivo es JSON delimitado por saltos de línea: un documento por línea, no un arreglo. Para convertirlo en un arreglo, ejecuta jq -s . users.json > users-array.json.
• Los mapas y arreglos se mantienen anidados. Cada línea también tiene un objeto __key__ de la exportación, que contiene el ID del documento.
• BigQuery escribe como máximo 1 GB por archivo. Para más, usa un comodín como gs://YOUR_BUCKET/users-*.json.
• La exportación se factura como una lectura de documento por documento. Borra la carpeta de exportación cuando termines para que deje de ocupar Cloud Storage.

Preguntas frecuentes

¿Puede Firebase console exportar datos de Firestore a JSON?

No. Realtime Database tiene Exportar JSON en el menú de su visor de datos, pero la pestaña Datos de Firestore no tiene descarga. La exportación administrada (la página Importar/Exportar de la consola de Google Cloud, o gcloud firestore export) escribe una copia de seguridad en el formato propio de Firestore en Cloud Storage, no JSON.

¿Por qué la API REST de Firestore devuelve valores como {"stringValue": "..."}?

La API REST envuelve cada campo en su tipo: stringValue, integerValue, timestampValue, mapValue y demás. Es JSON, pero no con la forma de tus documentos. El Admin SDK (método 2) desenvuelve esos tipos por ti.

¿Puedo importar el JSON de vuelta a Firestore?

No directamente. gcloud firestore import solo lee exportaciones administradas, y ninguno de estos archivos JSON lo es. Para cargar un archivo JSON, escríbelo de vuelta con un script (el BulkWriter del Admin SDK maneja lotes grandes). Si el objetivo es restaurar datos, usa la exportación e importación administradas en lugar de JSON.

¿Exportar datos de Firestore cuesta dinero?

Todos los métodos leen cada documento exportado al menos una vez, y Firestore los factura como lecturas de documentos. Dentro de la cuota gratuita diaria no cuesta nada. La exportación administrada además necesita la facturación habilitada en el proyecto, y sus archivos ocupan Cloud Storage hasta que los borres.