Node.js fs.writeFile: Write, Append and Create Files

fs.writeFile(path, data, callback) writes a string or Buffer to a file. If the file does not exist, Node creates it; if it does, the old contents are replaced. fs.writeFileSync(path, data) does the same and waits until the write is done, and fs.appendFile adds to the end of the file instead of replacing it.

const fs = require('fs');

fs.writeFile('hello.txt', 'Hello, file', (err) => {
    if (err) {
        console.error('Write failed:', err.message);
        return;
    }
    console.log('saved');
    console.log(fs.readFileSync('hello.txt', 'utf8'));
});

It prints saved and then the text it read back; the callback gets only an error (or null), never the data. Pass 42 instead of the string and the call throws a TypeError: the data must be a string or a Buffer.

writeFile, writeFileSync and fs/promises

The three forms take the same arguments and differ in how you wait for the result.

const fs = require('fs');
const fsp = require('fs/promises');

fs.writeFileSync('a.txt', 'one');            // blocks, throws on error

fs.writeFile('b.txt', 'two', (err) => {});   // callback with err

await fsp.writeFile('c.txt', 'three');       // promise, use in async code

Use writeFileSync in scripts and startup code, and the promise version in servers, where a sync write blocks every other request until the disk is done. The fs/promises page shows the rest of the promise API.

Append to a file with appendFile

writeFile replaces the whole file. To add a line to a log, use appendFile, which also creates the file the first time.

const fs = require('fs');

fs.writeFileSync('log.txt', 'first\n');
fs.writeFileSync('log.txt', 'second\n');
console.log(JSON.stringify(fs.readFileSync('log.txt', 'utf8')));

fs.appendFileSync('log.txt', 'third\n');
fs.appendFileSync('log.txt', 'fourth\n');
console.log(JSON.stringify(fs.readFileSync('log.txt', 'utf8')));

The first read prints "second\n", because the second writeFileSync replaced first, and the second prints "second\nthird\nfourth\n" (JSON.stringify makes the newlines visible). Add the \n yourself: neither function adds one.

Do not overwrite: the flag option

The third argument can be an options object. Its flag decides what happens to an existing file. 'wx' means "write, but fail if the file already exists", which is the safe way to create a file only once.

const fs = require('fs');

function createOnce(file, text) {
    try {
        fs.writeFileSync(file, text, { flag: 'wx' });
        console.log('created', file);
    } catch (err) {
        if (err.code === 'EEXIST') {
            console.log(file, 'already exists, left alone');
        } else {
            throw err;
        }
    }
}

createOnce('id.txt', 'abc123');
createOnce('id.txt', 'zzz999');
console.log(fs.readFileSync('id.txt', 'utf8'));

The second call fails with EEXIST, so the file still holds abc123. Change the second call's file name to id2.txt and both calls print created.

The flags you will meet most: 'w' (default, replace), 'a' (append), 'wx' (create only) and 'ax' (append, but only to a new file).

Checking with fs.existsSync first and then writing has a gap: another process can create the file between the check and the write. 'wx' does both in one step.

Write JSON to a file

writeFile does not accept objects. Turn them into text with JSON.stringify; the third argument, 2, indents the output so the file is readable.

const fs = require('fs');

const settings = { theme: 'dark', fontSize: 14, plugins: ['git', 'lint'] };

fs.writeFileSync('settings.json', JSON.stringify(settings, null, 2));

console.log(fs.readFileSync('settings.json', 'utf8'));

const loaded = JSON.parse(fs.readFileSync('settings.json', 'utf8'));
console.log(loaded.plugins.length);

The file holds the object over several indented lines, and parsing it back gives an equal object, so the last line prints 2. Pass the object without JSON.stringify and the call throws a TypeError.

Create the folder first with mkdir

writeFile creates files, not folders. Writing to reports/2026/june.txt when reports does not exist fails with ENOENT. Create the path first with mkdir and { recursive: true }, which creates every missing folder and does nothing if they already exist.

const fs = require('fs/promises');

async function main() {
    try {
        await fs.writeFile('reports/2026/june.txt', 'sales: 12');
    } catch (err) {
        console.log('first try:', err.code);
    }

    await fs.mkdir('reports/2026', { recursive: true });
    await fs.writeFile('reports/2026/june.txt', 'sales: 12');

    console.log(await fs.readdir('reports/2026'));
}
main();

The first write fails with ENOENT; after mkdir, the same write succeeds and readdir lists [ 'june.txt' ]. Build these paths with path.join in real code so they work on Windows too.

Common mistakes

Assuming the file is written right after the call. fs.writeFile returns before the data is on disk. Read the file or start the next step inside the callback, or await the promise version.

Losing data by writing in a loop. Calling writeFile once per item replaces the file each time, leaving only the last item. Use appendFile, or build the whole string and write it once.

Writing [object Object]. Passing an object through String() or a template literal writes [object Object]. Use JSON.stringify.