What Is the Markdown To Firebase List Converter?

The Markdown To Firebase List Converter on A.Tools transforms Markdown pipe-delimited tables into Firebase-compatible JSON list format. The output is ready to import into Firebase Realtime Database or Cloud Firestore using the Firebase CLI, Admin SDK, or REST API. All processing runs in your browser. No data leaves your device.

Firebase stores data as JSON trees. A Firebase list is an array of objects where each object represents a record. This converter maps each Markdown table row to a JSON object with keys from the header row — producing the exact structure Firebase expects.

How to Convert Markdown Tables to Firebase Lists?

Step 1: Provide Your Markdown Data

Click Enter Data to paste a Markdown table into the input area, or click Choose File to drag and drop a .md file. Press Sample to load example data.

Step 2: Edit in the Online Table Editor

Once parsed, an interactive spreadsheet appears. Use the toolbar to:

• Add or delete rows and columns

• Transpose the table (swap rows and columns)

• Remove duplicate rows

• Delete empty rows and columns

• Change text case (UPPERCASE, lowercase, Capitalize)

• Find and replace values — supports case-sensitive search and regex

• Toggle First Row as Header to define field names

Right-click any cell for context-menu operations.

Step 3: Configure Settings

In the Properties panel:

Step 4: Export

Click Convert to generate the Firebase JSON list. Use Copy to Clipboard or Download File to save as a .json file.

Key Features

• Two input modes: Paste Markdown directly or upload a .md file via drag-and-drop

• Full table editor: Edit, transpose, deduplicate, find-and-replace before converting

• Firebase-compatible output: JSON array of objects ready for database import

• Smart JSON parsing: Parse embedded JSON strings in cells into nested objects

• Client-side processing: Files never leave the browser — zero data upload

• Undo/Redo: Full edit history with revert support

• Context menu: Right-click for quick row/column/cell operations

• Header toggle: Treat the first row as field names or regular data

• Validation indicator: Real-time feedback on input validity

What the Output Looks Like

Given this Markdown input:

| name  | age | city        |
|-------|-----|-------------|
| Alice | 30  | New York    |
| Bob   | 25  | Los Angeles |

Default output

[
 {
   "name": "Alice",
   "age": "30",
   "city": "New York"
 },
 {
   "name": "Bob",
   "age": "25",
   "city": "Los Angeles"
 }
]

With Parse JSON enabled

If a cell contains a valid JSON string, it is parsed into a nested object:

| name  | age | metadata                |
|-------|-----|-------------------------|
| Alice | 30  | {"role":"admin","level":5} |
| Bob   | 25  | {"role":"user","level":1}  |

Output:

[
 {
   "name": "Alice",
   "age": "30",
   "metadata": {
     "role": "admin",
     "level": 5
   }
 },
 {
   "name": "Bob",
   "age": "25",
   "metadata": {
     "role": "user",
     "level": 1
   }
 }
]

For Firebase Realtime Database import

Upload via Firebase CLI:

firebase database:push /users data.json

Or import via the Firebase Console: Open your project → Realtime Database → click the three-dot menu → Import JSON.

For Firestore import

Use the Firebase Admin SDK with a batch write:

const admin = require("firebase-admin");
admin.initializeApp();
const data = require("./data.json");
const batch = admin.firestore().batch();
data.forEach((record) => {
   const ref = admin.firestore().collection("users").doc();
   batch.set(ref, record);
});
await batch.commit();

Understanding Firebase Database Lists

What is a Firebase list?

Firebase Realtime Database stores data as a JSON tree. A list in Firebase is a collection of child nodes under a parent path, typically represented as an array of objects or an object with auto-generated push IDs.

Array format vs Push ID format

This tool outputs the array format — ideal for:

• Initial database seeding

• Static reference data (countries, categories, config)

• Test fixtures and development data

• One-time bulk imports

For concurrent real-time applications, use Firebase's push() method to generate unique keys:

const ref = firebase.database().ref("users");
data.forEach((record) => {
 ref.push(record);
});

Firebase Realtime Database vs Cloud Firestore

Import methods

1. Firebase Console (simplest)

Open your Firebase project → Realtime Database → ⋮ menu → Import JSON → select your .json file.

2. Firebase CLI

firebase database:push /path/to/collection data.json

3. REST API

curl -X POST "https://your-project.firebaseio.com/users.json" \
 -d @data.json

4. Admin SDK (Node.js)

const admin = require("firebase-admin");
const serviceAccount = require("./serviceAccountKey.json");
admin.initializeApp({
 credential: admin.credential.cert(serviceAccount),
 databaseURL: "https://your-project.firebaseio.com"
});
const data = require("./data.json");
Promise.all(
 data.map((record) =>
   admin.database().ref("users").push(record)
 )
).then(() => console.log("Import complete"));

5. Admin SDK (Python)

import firebase_admin
from firebase_admin import credentials, db

cred = credentials.Certificate("serviceAccountKey.json")
firebase_admin.initialize_app(cred, {"databaseURL": "https://your-project.firebaseio.com"})

import json
with open("data.json") as f:
   data = json.load(f)

ref = db.reference("users")
for record in data:
   ref.push().set(record)

Settings: Parse JSON

When enabled, the tool inspects each cell value. If a cell contains a valid JSON string (object, array, number, boolean, or null), it is parsed into the corresponding JSON type in the output.

When to enable Parse JSON:

• Cells contain embedded JSON objects (coordinates, metadata, settings)

• Cells contain typed values that should be numbers, booleans, or null

• Firebase security rules expect specific data types (e.g., age must be a number)

When to leave it off:

• All data is simple text

• You want all values stored as strings in Firebase

• You are unsure whether cells contain valid JSON

Use Cases: When to Convert Markdown to Firebase

E-commerce Product Catalog Example

| id | name       | price  | category  | in_stock |
|----|------------|--------|-----------|----------|
| 1  | Widget A   | 29.99  | gadgets   | true     |
| 2  | Widget B   | 49.99  | gadgets   | false    |
| 3  | Gadget C   | 19.99  | tools     | true     |

Enable Parse JSON so 29.99 becomes a number and true becomes a boolean:

[
 {"id": "1", "name": "Widget A", "price": 29.99, "category": "gadgets", "in_stock": true},
 {"id": "2", "name": "Widget B", "price": 49.99, "category": "gadgets", "in_stock": false},
 {"id": "3", "name": "Gadget C", "price": 19.99, "category": "tools", "in_stock": true}
]

Import:

firebase database:set /products data.json

User Roles and Permissions Example

| role  | permissions                      | max_projects |
|-------|----------------------------------|-------------|
| admin | ["read","write","delete","admin"] | 999         |
| editor| ["read","write"]                  | 50          |
| viewer| ["read"]                          | 10          |

With Parse JSON enabled, the permissions column becomes a JSON array:

[
 {"role": "admin","permissions": ["read", "write", "delete", "admin"],"max_projects": 999  },
 {"role": "editor","permissions": ["read", "write"],"max_projects": 50  },
 {"role": "viewer","permissions": ["read"],"max_projects": 10  }
]

Location Reference Data Example

| city       | country | coords                |
|------------|---------|-----------------------|
| New York   | US      | {"lat":40.7,"lng":-74.0} |
| London     | UK      | {"lat":51.5,"lng":-0.1}  |
| Tokyo      | JP      | {"lat":35.7,"lng":139.7} |

With Parse JSON, coordinates become nested GeoJSON-style objects:

[
 {"city": "New York", "country": "US", "coords": {"lat": 40.7, "lng": -74.0}},
 {"city": "London", "country": "UK", "coords": {"lat": 51.5, "lng": -0.1}},
 {"city": "Tokyo", "country": "JP", "coords": {"lat": 35.7, "lng": 139.7}}
]

Frequently Asked Questions (FAQ)

• Does this tool upload my files to a server?

  No. All file parsing and conversion runs in your browser using JavaScript. Your data stays on your device. A.Tools never receives, stores, or transmits your file contents.

• What Markdown table formats are supported?

  The tool supports standard pipe-delimited Markdown tables following the CommonMark specification, including tables with or without leading/trailing pipes and alignment indicators.

• What output format does this tool produce?

  The tool produces a JSON array of objects. Each object represents one row from the Markdown table, with keys from the header row. This format is compatible with Firebase Realtime Database imports and Firestore batch writes.

• How do I import the JSON into Firebase?

  For Realtime Database: use the Firebase Console (Import JSON), Firebase CLI (firebase database:push), REST API (POST to .json endpoint), or Admin SDK. For Firestore: use the Admin SDK with batch writes.

• What does Parse JSON do?

  When enabled, the tool detects JSON strings inside cells and parses them into actual JSON types — numbers, booleans, null, nested objects, and arrays. Without it, all cell values remain as strings.

• Can I use this with Firestore?

  Yes. The JSON array output can be consumed by the Firebase Admin SDK for Firestore batch writes. Each array element becomes a document in a Firestore collection.

• Does the output include Firebase push IDs?

  No. The output is a plain JSON array without push IDs. To generate push IDs, use Firebase's push() method when writing data, or use the Firebase CLI import command which handles ID generation automatically.

• Can I edit the table before converting?

  Yes. After parsing, the full table editor lets you modify cells, add or remove rows and columns, transpose, deduplicate, change text case, and find-and-replace values.