JSON in Node.js: Complete Guide 2026

Stream Writing

const fs = require('fs');
const JSONStream = require('JSONStream');

const writeStream = fs.createWriteStream('output.json');
const jsonStream = JSONStream.stringify();

jsonStream.pipe(writeStream);

// Write items one at a time
for (let i = 0; i < 1000000; i++) {
  jsonStream.write({ id: i, name: User ${i} });
}

jsonStream.end();

writeStream.on('finish', () => {
  console.log('Wrote 1 million items');
});

Processing JSON Lines (JSONL)

const fs = require('fs');
const readline = require('readline');

async function processJSONL(filePath) {
  const fileStream = fs.createReadStream(filePath);
  const rl = readline.createInterface({
    input: fileStream,
    crlfDelay: Infinity
  });

  for await (const line of rl) {
    if (line.trim()) {
      const item = JSON.parse(line);
      await processItem(item);
    }
  }
}

// Efficient for multi-GB log files
await processJSONL('massive-logs.jsonl');

---

Express.js JSON Handling

Parsing Request Bodies

const express = require('express');
const app = express();

// Parse JSON request bodies
app.use(express.json({
  limit: '10mb', // Limit payload size
  strict: true, // Only accept arrays and objects
  type: 'application/json' // MIME type
}));

app.post('/api/users', (req, res) => {
  const { name, email } = req.body; // Already parsed!

  // Validate
  if (!name || !email) {
    return res.status(400).json({
      error: 'Missing required fields'
    });
  }

  // Process
  const user = createUser({ name, email });
  res.status(201).json(user);
});

Custom JSON Parser

app.use((req, res, next) => {
  if (req.headers['content-type'] === 'application/json') {
    let data = '';

    req.on('data', chunk => {
      data += chunk.toString();
    });

    req.on('end', () => {
      try {
        req.body = JSON.parse(data);
        next();
      } catch (error) {
        res.status(400).json({
          error: 'Invalid JSON',
          details: error.message
        });
      }
    });
  } else {
    next();
  }
});

Sending JSON Responses

app.get('/api/users', async (req, res) => {
  const users = await getUsers();

  // Method 1: res.json() (automatic Content-Type)
  res.json(users);

  // Method 2: Manual (more control)
  res.setHeader('Content-Type', 'application/json');
  res.send(JSON.stringify(users));

  // Method 3: Pretty print for debugging
  if (process.env.NODE_ENV === 'development') {
    res.send(JSON.stringify(users, null, 2));
  } else {
    res.json(users);
  }
});

Error Handling Middleware

app.use((error, req, res, next) => {
  // Handle JSON parse errors
  if (error instanceof SyntaxError && error.status === 400 && 'body' in error) {
    return res.status(400).json({
      error: 'Invalid JSON',
      message: error.message
    });
  }

  // Other errors
  res.status(500).json({
    error: 'Internal server error'
  });
});

---

Validation and Error Handling

Schema Validation with Ajv

const Ajv = require('ajv');
const ajv = new Ajv({ allErrors: true });

const userSchema = {
  type: 'object',
  properties: {
    name: { type: 'string', minLength: 1 },
    email: { type: 'string', format: 'email' },
    age: { type: 'integer', minimum: 0, maximum: 150 }
  },
  required: ['name', 'email'],
  additionalProperties: false
};

const validate = ajv.compile(userSchema);

function validateUser(data) {
  const valid = validate(data);
  if (!valid) {
    throw new Error(
      'Validation failed: ' + 
      JSON.stringify(validate.errors, null, 2)
    );
  }
  return true;
}

// Usage
try {
  validateUser({ name: 'John', email: 'john@example.com' });
} catch (error) {
  console.error(error.message);
}

Error Recovery Patterns

---

Performance Optimization

Fast JSON Stringification

const fastJson = require('fast-json-stringify');

const stringify = fastJson({
  type: 'object',
  properties: {
    id: { type: 'integer' },
    name: { type: 'string' },
    emails: {
      type: 'array',
      items: { type: 'string' }
    }
  }
});

const user = {
  id: 1,
  name: 'John',
  emails: ['john@example.com']
};

// 2-3x faster than JSON.stringify()
const json = stringify(user);

Caching Parsed Results

const cache = new Map();

function cachedReadJSON(filePath) {
  if (cache.has(filePath)) {
    return cache.get(filePath);
  }

  const data = JSON.parse(fs.readFileSync(filePath, 'utf8'));
  cache.set(filePath, data);

  return data;
}

// Watch for file changes and invalidate cache
fs.watch('config.json', () => {
  cache.delete('config.json');
});

Parallel Processing

const { Worker } = require('worker_threads');

function parseJSONInWorker(jsonString) {
  return new Promise((resolve, reject) => {
    const worker = new Worker(

      const { parentPort, workerData } = require('worker_threads');
      parentPort.postMessage(JSON.parse(workerData));
    , {
      eval: true,
      workerData: jsonString
    });

    worker.on('message', resolve);
    worker.on('error', reject);
    worker.on('exit', (code) => {
      if (code !== 0) {
        reject(new Error(Worker stopped with exit code ${code}));
      }
    });
  });
}

// Parse huge JSON without blocking main thread
const data = await parseJSONInWorker(hugeJSONString);

---

Production Patterns

Configuration Management

class Config {
  constructor() {
    this.data = {};
    this.load();
  }

  load() {
    const env = process.env.NODE_ENV || 'development';
    const configFile = config.${env}.json;

    try {
      this.data = require(./${configFile});
    } catch (error) {
      console.warn(No config for ${env}, using defaults);
      this.data = require('./config.default.json');
    }
  }

  get(key, defaultValue) {
    return key.split('.').reduce(
      (obj, k) => obj?.[k],
      this.data
    ) ?? defaultValue;
  }
}

const config = new Config();
const port = config.get('server.port', 3000);

Data Export Pipeline

async function exportUsersToJSON(outputPath) {
  const writeStream = fs.createWriteStream(outputPath);
  const jsonStream = JSONStream.stringify();

  jsonStream.pipe(writeStream);

  // Fetch in batches to avoid memory issues
  let offset = 0;
  const limit = 1000;

  while (true) {
    const users = await db.users.find({
      skip: offset,
      limit: limit
    });

    if (users.length === 0) break;

    for (const user of users) {
      jsonStream.write(user);
    }

    offset += limit;
  }

  jsonStream.end();

  return new Promise((resolve, reject) => {
    writeStream.on('finish', resolve);
    writeStream.on('error', reject);
  });
}

Rate-Limited API Responses