Colby Hemond
HomeAboutBlog
← Back to posts

Encoding Base64 with Node.js

Colby Hemond

Colby Hemond

June 13, 2022
2 minutes

You can encode a string to base64 in Node.js without the use of an ecosystem library. Node comes with "batteries included" and allows us to encode to base64 using a core API. In this article you will learn the following:

  • Encode a string to base64
  • Decode from base64 to a Unicode string
  • What the Buffer API is
  • How to create a base64 encode/decode utility

Encoding a string to base64

const string = 'this string will be converted to base64'
const stringBuffer = Buffer.from(string)
const stringBase64 = stringBuffer.toString('base64')

// Output: "dGhpcyBzdHJpbmcgd2lsbCBiZSBjb252ZXJ0ZWQgdG8gYmFzZTY0"

Decoding from base64 to a Unicode string

const base64String = 'dGhpcyBzdHJpbmcgd2lsbCBiZSBjb252ZXJ0ZWQgdG8gYmFzZTY0'
const base64Buffer = Buffer.from(base64String, 'base64')
const string = base64Buffer.toString()

// Output: "this string will be converted to base64"

What is the Buffer API anyway?

The Buffer API in Node is used to temporarily store data in memory—especially useful when handling large binary data like video, audio, or streamed content. It lets you encode/decode and manipulate data at the byte level.

Resources:

Creating a Base64 encode/decode utility

We'll use this knowledge to build and publish a lightweight NPM utility.

Steps:

  • Initialize the project
  • Install a test framework
  • Write the utility
  • Publish to NPM

Initialize the project

Create the folder:

node -e "fs.mkdirSync('simple-base64-string')"
cd simple-base64-string
npm init -y

Install a unit test framework

We'll use Mocha:

npm install --save-dev mocha

Update your package.json:

"scripts": {
  "test": "mocha"
}

Write the utility

Create a test folder and file:

node -e "fs.mkdirSync('test')"
cd test
node -e "fs.writeFileSync('encode.js', '')"

Now write the test:

import assert from 'assert'
import {encode} from '../index.js'

describe('String', () => {
  describe('encode', () => {
    it('should return the string encoded as base64', () => {
      assert.strictEqual(
        encode('this string will be converted to base64'),
        'dGhpcyBzdHJpbmcgd2lsbCBiZSBjb252ZXJ0ZWQgdG8gYmFzZTY0'
      )
    })
  })
})

Back in project root, create the index.js file:

node -e "fs.writeFileSync('index.js', '')"

Write the encode method:

export const encode = (string) => {
  const encodingBuffer = Buffer.from(string)
  return encodingBuffer.toString('base64')
}

Run your tests:

npm run test

Now extend the test file to include decode:

import assert from 'assert'
import {encode, decode} from '../index.js'

describe('String', () => {
  describe('encode', () => {
    it('should return the string encoded as base64', () => {
      assert.strictEqual(
        encode('this string will be converted to base64'),
        'dGhpcyBzdHJpbmcgd2lsbCBiZSBjb252ZXJ0ZWQgdG8gYmFzZTY0'
      )
    })
  })

  describe('decode', () => {
    it('should return the base64 string decoded to a human-readable string', () => {
      assert.strictEqual(
        decode('dGhpcyBzdHJpbmcgd2lsbCBiZSBjb252ZXJ0ZWQgdG8gYmFzZTY0'),
        'this string will be converted to base64'
      )
    })
  })
})

And add the decode function in index.js:

export const decode = (base64) => {
  const decodingBuffer = Buffer.from(base64, 'base64')
  return decodingBuffer.toString()
}

Test again:

npm run test

Publish to NPM

  1. Sign up for an NPM account
  2. Log in from your terminal:
npm login
  1. Publish the package:
npm publish

Example Usage

import {encode} from 'base64-string-lite'

const user = 'nodely'
const pass = 'N0d3!sC007'
const authString = `${user}:${pass}`

fetch('https://example.com', {
  method: 'GET',
  headers: {
    Authorization: `Basic ${encode(authString)}`
  }
})
  .then(res => res.json())
  .then(data => console.log(data))

Project Summary

In this tutorial, we explored:

  • Node.js’s built-in Buffer API
  • Encoding and decoding Base64
  • Writing unit tests with Mocha
  • Publishing a utility to NPM
nodejs
buffer
npm