Convert CSV to JSON for Firestore Bulk Import

Default settings. age stores as integer and active as boolean so range queries and rules work.

Input (users.csv):
name,age,active
Ada,36,true
Linus,54,false

Output (array, inference on):
[
  { "name": "Ada", "age": 36, "active": true },
  { "name": "Linus", "age": 54, "active": false }
]

// seed.js
const data = require('./users.json');
for (const r of data) await db.collection('users').add(r);

Keep IDs as strings (inference off) so you can pass them to .doc(id). Avoids zero-stripping a key like 00042.

Input:
id,name
00042,Ada

Output (inference OFF):
[ { "id": "00042", "name": "Ada" } ]

// seed with explicit doc id
for (const r of data) await db.collection('users').doc(r.id).set(r);

A blank nickname omits the field so the document is lean and the field reads as absent, not empty string.

Input:
name,nickname
Ada,
Linus,Tux

Output (Skip empty cells ON):
[ { "name": "Ada" }, { "name": "Linus", "nickname": "Tux" } ]

Stream NDJSON and commit in chunks of 500 to stay under Firestore's WriteBatch limit.

Output (NDJSON): one {record} per line

// pseudo-seed
let batch = db.batch(); let n = 0;
for (const line of readLines('data.ndjson')) {
  batch.set(db.collection('users').doc(), JSON.parse(line));
  if (++n % 500 === 0) { await batch.commit(); batch = db.batch(); }
}
await batch.commit();

Dates stay strings here; cast them in your script since the converter does not produce Firestore Timestamps.

Output element:
{ "name": "Ada", "joined": "2026-06-12" }

// in the seed, before writing:
r.joined = admin.firestore.Timestamp.fromDate(new Date(r.joined));

With inference on, an ID like 00042 becomes 42. If that column is your intended document ID (.doc(id)), turn off Infer numbers, booleans, null so it stays the exact string "00042". Inference is global, so if you also need typed data fields, keep inference off here and cast the few numeric fields in your seed script.

2026-06-12 stays a JSON string, so Firestore stores a string field, not a Timestamp. Convert in your seed: admin.firestore.Timestamp.fromDate(new Date(r.joined)) before writing. The converter has no Timestamp type because JSON has none.

A header address.city becomes a flat field literally named address.city, not a Firestore map { address: { city } }. To store a nested map, convert here, then run the array through json-unflattener to expand dotted keys into nested objects, which the Admin SDK stores as maps.

By default a blank cell becomes "", so the document has an empty-string field. For Firestore, an absent field and an empty string behave differently in queries and rules. Turn on Skip empty cells to omit the field so it reads as absent.

An ID beyond JavaScript's safe-integer range is kept as a string by inference, so it is not corrupted to a rounded number. This is ideal if you use it as a document ID (which must be a string anyway). If you need it numeric in a field, store it as a string and parse server-side, accepting Firestore's own number precision rules.

The converter happily produces an array of any size up to your tier cap, but Firestore's WriteBatch commits at most 500 writes. That limit lives in your seed script — chunk the array into 500-write batches (see the NDJSON example). The file shape itself imposes no such limit.

Two columns with the same header map to one field; the later value wins. Rename one column before converting so both values land in distinct Firestore fields.

Free tier caps at 2 MB / 500 rows. A real collection seed usually needs Pro (100 MB / 100,000 rows) or Developer (5 GB). For very large seeds, split the CSV into chunks under the cap, convert each to NDJSON, and stream-batch each file.