If your data may contain multi-byte sequences (not a plain ASCII sequence) and your browser has TextDecoder, then you should use that to decode your data (specify the required encoding for the TextDecoder):

var u8 = new Uint8Array([65, 66, 67, 68]);
var decoder = new TextDecoder('utf8');
var b64encoded = btoa(decoder.decode(u8));

If you need to support browsers that do not have TextDecoder (currently just IE and Edge), then the best option is to use a TextDecoder polyfill.

If your data contains plain ASCII (not multibyte Unicode/UTF-8) then there is a simple alternative using String.fromCharCode that should be fairly universally supported:

var ascii = new Uint8Array([65, 66, 67, 68]);
var b64encoded = btoa(String.fromCharCode.apply(null, ascii));

And to decode the base64 string back to a Uint8Array:

var u8_2 = new Uint8Array(atob(b64encoded).split("").map(function(c) {
    return c.charCodeAt(0); }));

If you have very large array buffers then the apply may fail with Maximum call stack size exceeded and you may need to chunk the buffer (based on the one posted by @RohitSengar). Again, note that this is only correct if your buffer only contains non-multibyte ASCII characters:

function Uint8ToString(u8a){
  var CHUNK_SZ = 0x8000;
  var c = [];
  for (var i=0; i < u8a.length; i+=CHUNK_SZ) {
    c.push(String.fromCharCode.apply(null, u8a.subarray(i, i+CHUNK_SZ)));
  }
  return c.join("");
}
// Usage
var u8 = new Uint8Array([65, 66, 67, 68]);
var b64encoded = btoa(Uint8ToString(u8));

If you are using Node.js then you can use this code to convert Uint8Array to base64

var u8 = new Uint8Array([65, 66, 67, 68]);
var b64 = Buffer.from(u8).toString('base64');

Native browser solution (fast!)

To base64-encode a Uint8Array with arbitrary data (not necessarily UTF-8) using native browser functionality:

// note: `buffer` arg can be an ArrayBuffer or a Uint8Array
async function bufferToBase64(buffer) {
  // use a FileReader to generate a base64 data URI:
  const base64url = await new Promise(r => {
    const reader = new FileReader()
    reader.onload = () => r(reader.result)
    reader.readAsDataURL(new Blob([buffer]))
  });
  // remove the `data:...;base64,` part from the start
  return base64url.slice(base64url.indexOf(',') + 1);
}

// example use:
await bufferToBase64(new Uint8Array([1,2,3,100,200]))

Because this is using native browser features, the performance is optimal. It can convert 250 MB per second on my computer (benchmark script), making it about 60x faster than the accepted answer.

Very simple solution and test for JavaScript!

ToBase64 = function (u8) {
    return btoa(String.fromCharCode.apply(null, u8));
}

FromBase64 = function (str) {
    return atob(str).split('').map(function (c) { return c.charCodeAt(0); });
}

var u8 = new Uint8Array(256);
for (var i = 0; i < 256; i++)
    u8[i] = i;

var b64 = ToBase64(u8);
console.debug(b64);
console.debug(FromBase64(b64));

function Uint8ToBase64(u8Arr){
  var CHUNK_SIZE = 0x8000; //arbitrary number
  var index = 0;
  var length = u8Arr.length;
  var result = '';
  var slice;
  while (index < length) {
    slice = u8Arr.subarray(index, Math.min(index + CHUNK_SIZE, length)); 
    result += String.fromCharCode.apply(null, slice);
    index += CHUNK_SIZE;
  }
  return btoa(result);
}

You can use this function if you have a very large Uint8Array. This is for Javascript, can be useful in case of FileReader readAsArrayBuffer.

Pure JS - no string middlestep (no btoa)

In below solution I omit conversion to string. IDEA is following:

• join 3 bytes (3 array elements) and you get 24-bits
• split 24bits to four 6-bit numbers (which take values from 0 to 63)
• use that numbers as index in base64 alphabet
• corner case: when input byte array the length is not divided by 3 then add = or == to result

Solution below works on 3-bytes chunks so it is good for large arrays. Similar solution to convert base64 to binary array (without atob) is HERE

function bytesArrToBase64(arr) {
  const abc = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; // base64 alphabet
  const bin = n => n.toString(2).padStart(8,0); // convert num to 8-bit binary string
  const l = arr.length
  let result = '';

  for(let i=0; i<=(l-1)/3; i++) {
    let c1 = i*3+1>=l; // case when "=" is on end
    let c2 = i*3+2>=l; // case when "=" is on end
    let chunk = bin(arr[3*i]) + bin(c1? 0:arr[3*i+1]) + bin(c2? 0:arr[3*i+2]);
    let r = chunk.match(/.{1,6}/g).map((x,j)=> j==3&&c2 ? '=' :(j==2&&c1 ? '=':abc[+('0b'+x)]));  
    result += r.join('');
  }

  return result;
}


// ----------
// TEST
// ----------

let test = "Alice's Adventure in Wondeland.";
let testBytes = [...test].map(c=> c.charCodeAt(0) );

console.log('test string:', test);
console.log('bytes:', JSON.stringify(testBytes));
console.log('btoa            ', btoa(test));
console.log('bytesArrToBase64', bytesArrToBase64(testBytes));

Caution!

If you want to convert STRING (not bytes array) be aware that btoa in general will fails on utf8 strings like btoa("💩") (one character may be encoded by more than one byte). In this case you must first convert such string to bytes in proper way and then use above solution e.g. :

function bytesArrToBase64(arr) {
  const abc = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; // base64 alphabet
  const bin = n => n.toString(2).padStart(8,0); // convert num to 8-bit binary string
  const l = arr.length
  let result = '';

  for(let i=0; i<=(l-1)/3; i++) {
    let c1 = i*3+1>=l; // case when "=" is on end
    let c2 = i*3+2>=l; // case when "=" is on end
    let chunk = bin(arr[3*i]) + bin(c1? 0:arr[3*i+1]) + bin(c2? 0:arr[3*i+2]);
    let r = chunk.match(/.{1,6}/g).map((x,j)=> j==3&&c2 ? '=' :(j==2&&c1 ? '=':abc[+('0b'+x)]));  
    result += r.join('');
  }

  return result;
}


// ----------
// TEST
// ----------

let test = "💩";   // base64: 8J+SqQ==
let testBytes = new TextEncoder().encode(test);

console.log('test string      :', test);
console.log('bytes            :', JSON.stringify([...testBytes]));
console.log('bytesArrToBase64 :', bytesArrToBase64(testBytes));


try {
  console.log('test btoa :', btoa(test));
} catch (e) {
  console.error('btoa fails during conversion!', e.message)
}

Snippets tested 2022-08-04 on: chrome 103.0.5060.134 (arm64), safari 15.2, firefox 103.0.1 (64 bit), edge 103.0.1264.77 (arm64), and node-js v12.16.1

MDN's docs cover btoa well.

Because you already have binary data, you can convert your Uint8Array into an ASCII string and invoke btoa on that string.

function encodeBase64Bytes(bytes: Uint8Array): string {
  return btoa(
    bytes.reduce((acc, current) => acc + String.fromCharCode(current), "")
  );
}

Complexity with btoa arises when you need to encode arbitrary JS strings, which may occupy more than a single byte, such as "👍". To handle arbitrary JS strings (which are UTF-16), you must first convert the string to a single byte representation. This is not applicable for this use case because you already have binary data.

The linked MDN documentation covers what that conversion looks like for encoding (and the reciprocal steps for decoding).

Native support for arrayBuffer to uint8array conversion has been recently added to the language.

Example usage:

const arr = new Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100]);
console.log(arr.toBase64()); // => 'SGVsbG8gV29ybGQ='

See the MDN docs for more details on the available parameters, and for browser support details.

There are polyfils available, such as this polyfill from core-js.

Use the following to convert uint8 array to base64 encoded string

function arrayBufferToBase64(buffer) {
            var binary = '';
            var bytes = [].slice.call(new Uint8Array(buffer));
            bytes.forEach((b) => binary += String.fromCharCode(b));
            return window.btoa(binary);
        };

Since btoa only works with strings, we can stringify the Uint8Array with String.fromCharCode:

const toBase64 = uInt8Array => btoa(String.fromCharCode(...uInt8Array));

A one liner for the browser:

Uint8Array --> Base64

btoa(String.fromCharCode.apply(null,new Uint8Array([1,2,3,255])))

Base64 --> Uint8Array

new Uint8Array([...atob('AQID/w==')].map(c=>c.charCodeAt()))

Several people were asking how it works, so I thought I'd finally break it down for everyone:

// Uint8Array --> Base64
//
// btoa(String.fromCharCode.apply(null,new Uint8Array([1,2,3,255])))
//
// breaks down to:


input = new Uint8Array([1,2,3,255])
// convert input to string (by applying the function 'fromCharCode' to each element of the input array)
inputString = String.fromCharCode.apply(null, input)
// now we have a string we can use the 'btoa' function to do all the hard work
base64String = btoa(inputString)

// Base64 --> Uint8Array
//
// new Uint8Array([...atob('AQID/w==')].map(c=>c.charCodeAt()))
//
// breaks down to:

// use the built in function to decode the base64
base64String = atob('AQID/w==')
// convert string to array of characters
base64Array = [...base64String]
// convert characters to bytes
bytes = base64Array.map(c=>c.charCodeAt())
// convert array of bytes to an Uint8Array
bytesArray = new Uint8Array(b)

Here's a solution that works for strings longer than 255 elements, because it doesn't use the "splat operator" (Spread syntax):

function uint8ArrayFromBase64(s) {
  // 1. Call atob()
  var b = atob(s);
  // 2. Construct Uint8Array from String
  return Uint8Array.from(b, c => c.charCodeAt(0));
}

function uint8ArrayToBase64(arr) {
  // 1. Preprocess Uint8Array into String
  // (TODO: fix RAM usage from intermediate array creation)
  var b = arr.map(c => String.fromCharCode(c)).join(String());
  // 2. Call btoa()
  return btoa(b);
}

Demo:

<form action="javascript:" onsubmit="(({target:form,submitter:{value:action}})=>{eval(action)(form)})(event)">
<input name="b64" value="AAAAB3NzaC1yc2E=">
<button type="submit" value="({b64,u8a})=>{u8a.value=`[${uint8ArrayFromBase64(b64.value)}]`;}">Convert to Uint8Array</button>
<br />
<input name="u8a" value="">
<button type="submit" value="({u8a,b64})=>{b64.value=(uint8ArrayToBase64(u8a.value.replace(/(?:^\[|\]$)/g, '').split(',')));}">Convert to Base64</button>
</form>

As of July 2025 Firefox and Safari support .toBase64() on Uint8Array.

The toBase64() method of Uint8Array instances returns a base64-encoded string based on the data in this Uint8Array object.

const myBase64String = myUint8Array.toBase64();

To decode from base64 to a Uint8Array use Uint8Array.fromBase64().

The Uint8Array.fromBase64() static method creates a new Uint8Array object from a base64-encoded string.

const myUint8Array = Uint8Array.fromBase64(myBase64String);

// This creates a Uint8Array from a string.
const bytes = new TextEncoder().encode("Hello, unicode world 😋");

// Encode to base64.
const base64 = bytes.toBase64();
console.log(base64);

// To decode from base64. First get a Uint8Array.
const decodedBytes = Uint8Array.fromBase64(base64);

// And now convert it back to a string.
const decoded = new TextDecoder().decode(decodedBytes);
console.log(decoded);

Polyfills are available at https://www.npmjs.com/package/es-arraybuffer-base64

For Node.js

const bytes = new Uint8Array([0, 1, 2, 3]);
const base64 = Buffer.from(bytes.buffer).toString("base64");

For Browsers

Nowadays, Uint8Array.prototype.toBase64() is implemented in modern browsers.

const bytes = new Uint8Array([0, 1, 2, 3]);
const base64 = bytes.toBase64();

If you want to support older browsers, you may use FileReader.readAsDataURL and btoa.

FileReader.readAsDataURL

function toBase64(bytes) {
    return new Promise(r => {
        const reader = new FileReader()
        reader.onload = () => r(reader.result)
        reader.readAsDataURL(new Blob([bytes]))
    }).then(url => url.slice(url.indexOf(",") + 1));
}

const bytes = new Uint8Array([0, 1, 2, 3]);
const base64 = await toBase64(bytes);

btoa

const bytes = new Uint8Array([0, 1, 2, 3]);
const base64 = btoa(bytes.reduce((data, byte) => data + String.fromCharCode(byte), ""));

Please note that String.fromCharCode should be used instead of TextDecoder to support non-printable characters. Also, bytes.reduce should be used instead of String.fromCharCode(...bytes) to support long data.

Write Your Own

Of course you can write your own Base64 encoding function.

function toBase64(bytes) {
    const dict = [
        "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z",
        "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z",
        "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "+", "/"
    ];
    let base64 = "";
    let i;
    for (i = 0; i < bytes.length - 3; i += 3) {
        const byte1 = bytes[i];
        const byte2 = bytes[i + 1];
        const byte3 = bytes[i + 2];
        base64 += dict[byte1 >>> 2] + dict[(byte1 & 3) << 4 | byte2 >>> 4] + dict[(byte2 & 15) << 2 | byte3 >>> 6] + dict[byte3 & 63];
    }
    const has2 = i + 1 < bytes.length;
    const byte1 = bytes[i];
    const byte2 = has2 ? bytes[i + 1] : 0;
    base64 += dict[byte1 >>> 2] + dict[(byte1 & 3) << 4 | byte2 >>> 4];
    if (has2) {
        const has3 = i + 2 < bytes.length;
        const byte3 = has3 ? bytes[i + 2] : 0;
        return base64 + dict[(byte2 & 15) << 2 | byte3 >>> 6] + (has3 ? dict[byte3 & 63] : "=");
    }
    return base64 + "==";
}

const bytes = new Uint8Array([0, 1, 2, 3]);
const base64 = toBase64(bytes);

Performance

If you want to know the performance differences between different methods, you can see it here.

Here is a JS Function to this:

This function is needed because Chrome doesn't accept a base64 encoded string as value for applicationServerKey in pushManager.subscribe yet https://bugs.chromium.org/p/chromium/issues/detail?id=802280

function urlBase64ToUint8Array(base64String) {
  var padding = '='.repeat((4 - base64String.length % 4) % 4);
  var base64 = (base64String + padding)
    .replace(/\-/g, '+')
    .replace(/_/g, '/');

  var rawData = window.atob(base64);
  var outputArray = new Uint8Array(rawData.length);

  for (var i = 0; i < rawData.length; ++i) {
    outputArray[i] = rawData.charCodeAt(i);
  }
  return outputArray;
}