Firexport / Guides

Comment exporter des données Firestore en JSON

Realtime Database a un bouton Exporter au format JSON dans la console Firebase. Firestore, non. Il existe trois façons pratiques de sortir des documents Firestore en JSON, des résultats d’une requête à une collection entière avec ses sous-collections.

Mis à jour le 24 septembre 2026. Firexport, l’extension de la méthode 1, est la nôtre. Les méthodes 2 et 3 n’en ont pas besoin.

1. Exporter depuis la console Firebase avec Firexport

La page Firestore de la console Firebase a un générateur de requêtes (Query builder) qui exécute une requête et affiche les résultats dans un tableau, mais rien pour les télécharger. Firexport est une extension Chrome gratuite qui ajoute un bouton Exporter à côté de ces résultats.

1. Installez Firexport depuis le Chrome Web Store.
2. Dans la console Firebase, ouvrez Firestore Database et passez de la vue en panneaux (Panel view) au générateur de requêtes (Query builder) (en haut à droite de l’onglet Données).
3. Choisissez la collection sous Portée de la requête (Query scope) et Chemin (Path), ajoutez des filtres ou une limite si vous voulez, et cliquez sur Exécuter (Run).
4. Ouvrez le menu ⋮ à côté du bouton Exporter et choisissez Exporter en JSON. Firexport parcourt toutes les pages de résultats et télécharge un seul fichier JSON. (Le bouton Exporter lui-même enregistre du CSV.)

Le fichier est un tableau JSON avec un objet par document : une clé Document ID, puis les champs du document. Les nombres, booléens et null gardent leur type JSON, et les maps et tableaux sortent imbriqués. Ce qui diffère entre la version gratuite et Advanced, ce sont les valeurs que la console n’affiche que sous forme de texte :

Gratuit — horodatages, geopoints et références tels que la console les affiche :

[
  {
    "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 (licence à paiement unique) — les mêmes valeurs restaurées à partir des données que la console a déjà chargées :

[
  {
    "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"
  }
]

Dans la version gratuite, une map ou un tableau dont le texte de la console ne peut pas être relu en JSON (un que la console a coupé par « … », par exemple) reste une chaîne. Advanced les écrit en entier. Dans les deux cas, aucune clé de compte de service ni facturation à configurer : cela fonctionne dans la session de console où vous êtes déjà connecté, et le fichier est construit dans votre navigateur. Cela fonctionne dans Chrome et les autres navigateurs basés sur Chromium.

Exportez votre prochaine requête Firestore en JSON depuis la console, sans script ni clé de compte de service.

Ajouter à Chrome — gratuit

2. Exporter avec un script Admin SDK

Un court script Node.js avec le SDK Admin Firebase peut exporter une collection entière, et descendre dans les sous-collections, ce qu’aucune des deux autres méthodes ne fait. Il lui faut un compte qui peut lire Firestore : un Propriétaire ou un Éditeur du projet, ou le rôle Lecteur Cloud Datastore.

1. Installez le SDK : npm install firebase-admin
2. Connectez-vous pour obtenir des identifiants locaux : gcloud auth application-default login. Sur un serveur, faites plutôt pointer GOOGLE_APPLICATION_CREDENTIALS vers une clé de compte de service.
3. Enregistrez le script ci-dessous sous export-to-json.mjs, remplacez your-project-id et exécutez node export-to-json.mjs users. Ajoutez --subcollections pour inclure les sous-collections de chaque document.

// 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`);

• Avec --subcollections, chaque document qui a des sous-collections reçoit une clé __collections__ qui les contient, imbriquées aussi profond qu’elles vont. Les trouver coûte une requête de plus par document, donc les grandes collections prennent plus de temps.
• Les sous-collections sous un document qui n’existe pas lui-même (la console affiche son ID en italique) ne sont pas atteintes depuis la collection parente. Exportez-les par groupe de collections.
• Le script garde tout en mémoire avant d’écrire le fichier. Pour des millions de documents, utilisez la méthode 3.

3. Exporter avec gcloud et BigQuery

L’export géré de Firestore écrit une sauvegarde dans Cloud Storage au format propre de Firestore, pas en JSON. BigQuery peut charger ce format et le réécrire en JSON. C’est la voie pour les grandes collections, mais elle exige la facturation activée (formule Blaze) et l’autorisation d’exécuter des exports et d’écrire dans le bucket. La documentation d’export et d’import de Google liste les rôles.

# 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 .

• Le fichier est du JSON délimité par des sauts de ligne : un document par ligne, pas un tableau. Pour en faire un tableau, exécutez jq -s . users.json > users-array.json.
• Les maps et les tableaux restent imbriqués. Chaque ligne a aussi un objet __key__ issu de l’export, qui contient l’ID du document.
• BigQuery écrit au plus 1 Go par fichier. Au-delà, utilisez un joker comme gs://YOUR_BUCKET/users-*.json.
• L’export est facturé une lecture de document par document. Supprimez le dossier d’export une fois terminé pour qu’il cesse d’occuper Cloud Storage.

FAQ

La console Firebase peut-elle exporter des données Firestore en JSON ?

Non. Realtime Database a Exporter au format JSON dans le menu de sa visionneuse de données, mais l’onglet Données de Firestore n’a pas de téléchargement. L’export géré (la page Importer/Exporter de la console Google Cloud, ou gcloud firestore export) écrit une sauvegarde au format propre de Firestore dans Cloud Storage, pas du JSON.

Pourquoi l’API REST de Firestore renvoie-t-elle des valeurs comme {"stringValue": "..."} ?

L’API REST enveloppe chaque champ dans son type : stringValue, integerValue, timestampValue, mapValue, etc. C’est du JSON, mais pas la forme de vos documents. Le SDK Admin (méthode 2) retire ces types pour vous.

Puis-je réimporter le JSON dans Firestore ?

Pas directement. gcloud firestore import ne lit que les exports gérés, et aucun de ces fichiers JSON n’en est un. Pour charger un fichier JSON, réécrivez-le avec un script (le BulkWriter du SDK Admin gère les gros lots). Si le but est de restaurer des données, utilisez l’export et l’import gérés plutôt que du JSON.

Exporter des données Firestore coûte-t-il de l’argent ?

Chaque méthode lit chaque document exporté au moins une fois, et Firestore facture ces lectures de documents. Dans le quota gratuit quotidien, cela ne coûte rien. L’export géré exige en plus la facturation activée sur le projet, et ses fichiers occupent Cloud Storage jusqu’à ce que vous les supprimiez.