diff --git a/doc/api/buffer.md b/doc/api/buffer.md
index c1423229ca6a34..76c920f0b661d4 100644
--- a/doc/api/buffer.md
+++ b/doc/api/buffer.md
@@ -50,6 +50,9 @@ const buf7 = Buffer.from('tést', 'latin1');
 ## Buffers and character encodings
 <!-- YAML
 changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/36952
+    description: Introduced `base64url` encoding.
   - version: v6.4.0
     pr-url: https://github.com/nodejs/node/pull/7111
     description: Introduced `latin1` as an alias for `binary`.
@@ -106,6 +109,11 @@ string into a `Buffer` as decoding.
   specified in [RFC 4648, Section 5][]. Whitespace characters such as spaces,
   tabs, and new lines contained within the base64-encoded string are ignored.
 
+* `'base64url'`: [base64url][] encoding as specified in
+  [RFC 4648, Section 5][]. When creating a `Buffer` from a string, this
+  encoding will also correctly accept regular base64-encoded strings. When
+  encoding a `Buffer` to a string, this encoding will omit padding.
+
 * `'hex'`: Encode each byte as two hexadecimal characters. Data truncation
   may occur when decoding strings that do exclusively contain valid hexadecimal
   characters. See below for an example.
@@ -469,9 +477,10 @@ Returns the byte length of a string when encoded using `encoding`.
 This is not the same as [`String.prototype.length`][], which does not account
 for the encoding that is used to convert the string into bytes.
 
-For `'base64'` and `'hex'`, this function assumes valid input. For strings that
-contain non-base64/hex-encoded data (e.g. whitespace), the return value might be
-greater than the length of a `Buffer` created from the string.
+For `'base64'`, `'base64url'`, and `'hex'`, this function assumes valid input.
+For strings that contain non-base64/hex-encoded data (e.g. whitespace), the
+return value might be greater than the length of a `Buffer` created from the
+string.
 
 ```js
 const str = '\u00bd + \u00bc = \u00be';
@@ -3427,6 +3436,7 @@ introducing security vulnerabilities into an application.
 [`buffer.kMaxLength`]: #buffer_buffer_kmaxlength
 [`util.inspect()`]: util.md#util_util_inspect_object_options
 [`v8::TypedArray::kMaxLength`]: https://v8.github.io/api/head/classv8_1_1TypedArray.html#a54a48f4373da0850663c4393d843b9b0
+[base64url]: https://tools.ietf.org/html/rfc4648#section-5
 [binary strings]: https://developer.mozilla.org/en-US/docs/Web/API/DOMString/Binary
 [endianness]: https://en.wikipedia.org/wiki/Endianness
 [iterator]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols
diff --git a/lib/buffer.js b/lib/buffer.js
index b16d696b023fe1..15f6f18f49c661 100644
--- a/lib/buffer.js
+++ b/lib/buffer.js
@@ -659,6 +659,20 @@ const encodingOps = {
                     encodingsMap.base64,
                     dir)
   },
+  base64url: {
+    encoding: 'base64url',
+    encodingVal: encodingsMap.base64url,
+    byteLength: (string) => base64ByteLength(string, string.length),
+    write: (buf, string, offset, len) =>
+      buf.base64urlWrite(string, offset, len),
+    slice: (buf, start, end) => buf.base64urlSlice(start, end),
+    indexOf: (buf, val, byteOffset, dir) =>
+      indexOfBuffer(buf,
+                    fromStringFast(val, encodingOps.base64url),
+                    byteOffset,
+                    encodingsMap.base64url,
+                    dir)
+  },
   hex: {
     encoding: 'hex',
     encodingVal: encodingsMap.hex,
@@ -715,6 +729,11 @@ function getEncodingOps(encoding) {
       if (encoding === 'hex' || StringPrototypeToLowerCase(encoding) === 'hex')
         return encodingOps.hex;
       break;
+    case 9:
+      if (encoding === 'base64url' ||
+          StringPrototypeToLowerCase(encoding) === 'base64url')
+        return encodingOps.base64url;
+      break;
   }
 }
 
diff --git a/lib/internal/buffer.js b/lib/internal/buffer.js
index dd27c15957f1ac..f366bef638fb48 100644
--- a/lib/internal/buffer.js
+++ b/lib/internal/buffer.js
@@ -18,12 +18,14 @@ const { validateNumber } = require('internal/validators');
 const {
   asciiSlice,
   base64Slice,
+  base64urlSlice,
   latin1Slice,
   hexSlice,
   ucs2Slice,
   utf8Slice,
   asciiWrite,
   base64Write,
+  base64urlWrite,
   latin1Write,
   hexWrite,
   ucs2Write,
@@ -1026,12 +1028,14 @@ function addBufferPrototypeMethods(proto) {
 
   proto.asciiSlice = asciiSlice;
   proto.base64Slice = base64Slice;
+  proto.base64urlSlice = base64urlSlice;
   proto.latin1Slice = latin1Slice;
   proto.hexSlice = hexSlice;
   proto.ucs2Slice = ucs2Slice;
   proto.utf8Slice = utf8Slice;
   proto.asciiWrite = asciiWrite;
   proto.base64Write = base64Write;
+  proto.base64urlWrite = base64urlWrite;
   proto.latin1Write = latin1Write;
   proto.hexWrite = hexWrite;
   proto.ucs2Write = ucs2Write;
diff --git a/lib/internal/util.js b/lib/internal/util.js
index c28f51e40c9f61..9127c5a83e278e 100644
--- a/lib/internal/util.js
+++ b/lib/internal/util.js
@@ -177,6 +177,11 @@ function slowCases(enc) {
         `${enc}`.toLowerCase() === 'utf-16le')
         return 'utf16le';
       break;
+    case 9:
+      if (enc === 'base64url' || enc === 'BASE64URL' ||
+          `${enc}`.toLowerCase() === 'base64url')
+        return 'base64url';
+      break;
     default:
       if (enc === '') return 'utf8';
   }
diff --git a/src/api/encoding.cc b/src/api/encoding.cc
index 6df4a7faf30393..f64aeee15c3b34 100644
--- a/src/api/encoding.cc
+++ b/src/api/encoding.cc
@@ -68,6 +68,8 @@ enum encoding ParseEncoding(const char* encoding,
       } else if (encoding[1] == 'a') {
         if (strncmp(encoding + 2, "se64", 5) == 0)
           return BASE64;
+        if (strncmp(encoding + 2, "se64url", 8) == 0)
+          return BASE64URL;
       }
       if (StringEqualNoCase(encoding, "binary"))
         return LATIN1;  // BINARY is a deprecated alias of LATIN1.
@@ -75,6 +77,8 @@ enum encoding ParseEncoding(const char* encoding,
         return BUFFER;
       if (StringEqualNoCase(encoding, "base64"))
         return BASE64;
+      if (StringEqualNoCase(encoding, "base64url"))
+        return BASE64URL;
       break;
 
     case 'a':
diff --git a/src/base64-inl.h b/src/base64-inl.h
index 9efb9d076ea8e5..1b6cdd93f002a4 100644
--- a/src/base64-inl.h
+++ b/src/base64-inl.h
@@ -123,12 +123,13 @@ size_t base64_decode(char* const dst, const size_t dstlen,
 inline size_t base64_encode(const char* src,
                             size_t slen,
                             char* dst,
-                            size_t dlen) {
+                            size_t dlen,
+                            Base64Mode mode) {
   // We know how much we'll write, just make sure that there's space.
-  CHECK(dlen >= base64_encoded_size(slen) &&
+  CHECK(dlen >= base64_encoded_size(slen, mode) &&
         "not enough space provided for base64 encode");
 
-  dlen = base64_encoded_size(slen);
+  dlen = base64_encoded_size(slen, mode);
 
   unsigned a;
   unsigned b;
@@ -137,9 +138,7 @@ inline size_t base64_encode(const char* src,
   unsigned k;
   unsigned n;
 
-  static const char table[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-                              "abcdefghijklmnopqrstuvwxyz"
-                              "0123456789+/";
+  const char* table = base64_select_table(mode);
 
   i = 0;
   k = 0;
@@ -164,8 +163,10 @@ inline size_t base64_encode(const char* src,
       a = src[i + 0] & 0xff;
       dst[k + 0] = table[a >> 2];
       dst[k + 1] = table[(a & 3) << 4];
-      dst[k + 2] = '=';
-      dst[k + 3] = '=';
+      if (mode == Base64Mode::NORMAL) {
+        dst[k + 2] = '=';
+        dst[k + 3] = '=';
+      }
       break;
     case 2:
       a = src[i + 0] & 0xff;
@@ -173,7 +174,8 @@ inline size_t base64_encode(const char* src,
       dst[k + 0] = table[a >> 2];
       dst[k + 1] = table[((a & 3) << 4) | (b >> 4)];
       dst[k + 2] = table[(b & 0x0f) << 2];
-      dst[k + 3] = '=';
+      if (mode == Base64Mode::NORMAL)
+        dst[k + 3] = '=';
       break;
   }
 
diff --git a/src/base64.h b/src/base64.h
index e58baa5f6e4692..cf6e82539a5f91 100644
--- a/src/base64.h
+++ b/src/base64.h
@@ -5,13 +5,40 @@
 
 #include "util.h"
 
+#include <cmath>
 #include <cstddef>
 #include <cstdint>
 
 namespace node {
 //// Base 64 ////
-static inline constexpr size_t base64_encoded_size(size_t size) {
-  return ((size + 2) / 3 * 4);
+
+enum class Base64Mode {
+  NORMAL,
+  URL
+};
+
+static constexpr char base64_table[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+                                       "abcdefghijklmnopqrstuvwxyz"
+                                       "0123456789+/";
+
+static constexpr char base64_table_url[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+                                           "abcdefghijklmnopqrstuvwxyz"
+                                           "0123456789-_";
+
+static inline const char* base64_select_table(Base64Mode mode) {
+  switch (mode) {
+    case Base64Mode::NORMAL: return base64_table;
+    case Base64Mode::URL: return base64_table_url;
+    default: UNREACHABLE();
+  }
+}
+
+static inline constexpr size_t base64_encoded_size(
+    size_t size,
+    Base64Mode mode = Base64Mode::NORMAL) {
+  return mode == Base64Mode::NORMAL
+      ? ((size + 2) / 3 * 4)
+      : std::ceil(static_cast<double>(size * 4) / 3);
 }
 
 // Doesn't check for padding at the end.  Can be 1-2 bytes over.
@@ -32,7 +59,8 @@ size_t base64_decode(char* const dst, const size_t dstlen,
 inline size_t base64_encode(const char* src,
                             size_t slen,
                             char* dst,
-                            size_t dlen);
+                            size_t dlen,
+                            Base64Mode mode = Base64Mode::NORMAL);
 }  // namespace node
 
 
diff --git a/src/node.h b/src/node.h
index f1b11aaa3edc90..d19deab7cc7f64 100644
--- a/src/node.h
+++ b/src/node.h
@@ -664,7 +664,18 @@ inline void NODE_SET_PROTOTYPE_METHOD(v8::Local<v8::FunctionTemplate> recv,
 #define NODE_SET_PROTOTYPE_METHOD node::NODE_SET_PROTOTYPE_METHOD
 
 // BINARY is a deprecated alias of LATIN1.
-enum encoding {ASCII, UTF8, BASE64, UCS2, BINARY, HEX, BUFFER, LATIN1 = BINARY};
+// BASE64URL is not currently exposed to the JavaScript side.
+enum encoding {
+  ASCII,
+  UTF8,
+  BASE64,
+  UCS2,
+  BINARY,
+  HEX,
+  BUFFER,
+  BASE64URL,
+  LATIN1 = BINARY
+};
 
 NODE_EXTERN enum encoding ParseEncoding(
     v8::Isolate* isolate,
diff --git a/src/node_buffer.cc b/src/node_buffer.cc
index 8781c02b2f6e70..455c2b4949d23b 100644
--- a/src/node_buffer.cc
+++ b/src/node_buffer.cc
@@ -1163,6 +1163,7 @@ void Initialize(Local<Object> target,
 
   env->SetMethodNoSideEffect(target, "asciiSlice", StringSlice<ASCII>);
   env->SetMethodNoSideEffect(target, "base64Slice", StringSlice<BASE64>);
+  env->SetMethodNoSideEffect(target, "base64urlSlice", StringSlice<BASE64URL>);
   env->SetMethodNoSideEffect(target, "latin1Slice", StringSlice<LATIN1>);
   env->SetMethodNoSideEffect(target, "hexSlice", StringSlice<HEX>);
   env->SetMethodNoSideEffect(target, "ucs2Slice", StringSlice<UCS2>);
@@ -1170,6 +1171,7 @@ void Initialize(Local<Object> target,
 
   env->SetMethod(target, "asciiWrite", StringWrite<ASCII>);
   env->SetMethod(target, "base64Write", StringWrite<BASE64>);
+  env->SetMethod(target, "base64urlWrite", StringWrite<BASE64URL>);
   env->SetMethod(target, "latin1Write", StringWrite<LATIN1>);
   env->SetMethod(target, "hexWrite", StringWrite<HEX>);
   env->SetMethod(target, "ucs2Write", StringWrite<UCS2>);
diff --git a/src/string_bytes.cc b/src/string_bytes.cc
index c1b3229e6077c9..daff1424d22e5a 100644
--- a/src/string_bytes.cc
+++ b/src/string_bytes.cc
@@ -358,6 +358,8 @@ size_t StringBytes::Write(Isolate* isolate,
       break;
     }
 
+    case BASE64URL:
+      // Fall through
     case BASE64:
       if (str->IsExternalOneByte()) {
         auto ext = str->GetExternalOneByteStringResource();
@@ -425,6 +427,8 @@ Maybe<size_t> StringBytes::StorageSize(Isolate* isolate,
       data_size = str->Length() * sizeof(uint16_t);
       break;
 
+    case BASE64URL:
+      // Fall through
     case BASE64:
       data_size = base64_decoded_size_fast(str->Length());
       break;
@@ -466,6 +470,8 @@ Maybe<size_t> StringBytes::Size(Isolate* isolate,
     case UCS2:
       return Just(str->Length() * sizeof(uint16_t));
 
+    case BASE64URL:
+      // Fall through
     case BASE64: {
       String::Value value(isolate, str);
       return Just(base64_decoded_size(*value, value.length()));
@@ -691,6 +697,20 @@ MaybeLocal<Value> StringBytes::Encode(Isolate* isolate,
       return ExternOneByteString::New(isolate, dst, dlen, error);
     }
 
+    case BASE64URL: {
+      size_t dlen = base64_encoded_size(buflen, Base64Mode::URL);
+      char* dst = node::UncheckedMalloc(dlen);
+      if (dst == nullptr) {
+        *error = node::ERR_MEMORY_ALLOCATION_FAILED(isolate);
+        return MaybeLocal<Value>();
+      }
+
+      size_t written = base64_encode(buf, buflen, dst, dlen, Base64Mode::URL);
+      CHECK_EQ(written, dlen);
+
+      return ExternOneByteString::New(isolate, dst, dlen, error);
+    }
+
     case HEX: {
       size_t dlen = buflen * 2;
       char* dst = node::UncheckedMalloc(dlen);
diff --git a/src/string_decoder.cc b/src/string_decoder.cc
index 779d60356d609d..fc37cbe29e40bf 100644
--- a/src/string_decoder.cc
+++ b/src/string_decoder.cc
@@ -69,7 +69,10 @@ MaybeLocal<String> StringDecoder::DecodeData(Isolate* isolate,
 
   size_t nread = *nread_ptr;
 
-  if (Encoding() == UTF8 || Encoding() == UCS2 || Encoding() == BASE64) {
+  if (Encoding() == UTF8 ||
+      Encoding() == UCS2 ||
+      Encoding() == BASE64 ||
+      Encoding() == BASE64URL) {
     // See if we want bytes to finish a character from the previous
     // chunk; if so, copy the new bytes to the missing bytes buffer
     // and create a small string from it that is to be prepended to the
@@ -197,7 +200,7 @@ MaybeLocal<String> StringDecoder::DecodeData(Isolate* isolate,
           state_[kBufferedBytes] = 2;
           state_[kMissingBytes] = 2;
         }
-      } else if (Encoding() == BASE64) {
+      } else if (Encoding() == BASE64 || Encoding() == BASE64URL) {
         state_[kBufferedBytes] = nread % 3;
         if (state_[kBufferedBytes] > 0)
           state_[kMissingBytes] = 3 - BufferedBytes();
@@ -310,6 +313,7 @@ void InitializeStringDecoder(Local<Object> target,
   ADD_TO_ENCODINGS_ARRAY(ASCII, "ascii");
   ADD_TO_ENCODINGS_ARRAY(UTF8, "utf8");
   ADD_TO_ENCODINGS_ARRAY(BASE64, "base64");
+  ADD_TO_ENCODINGS_ARRAY(BASE64URL, "base64url");
   ADD_TO_ENCODINGS_ARRAY(UCS2, "utf16le");
   ADD_TO_ENCODINGS_ARRAY(HEX, "hex");
   ADD_TO_ENCODINGS_ARRAY(BUFFER, "buffer");
diff --git a/test/addons/parse-encoding/binding.cc b/test/addons/parse-encoding/binding.cc
index cdbd8e44466db8..7fae5bf4bdb61c 100644
--- a/test/addons/parse-encoding/binding.cc
+++ b/test/addons/parse-encoding/binding.cc
@@ -6,6 +6,7 @@ namespace {
 #define ENCODING_MAP(V) \
   V(ASCII)              \
   V(BASE64)             \
+  V(BASE64URL)          \
   V(BUFFER)             \
   V(HEX)                \
   V(LATIN1)             \
diff --git a/test/addons/parse-encoding/test.js b/test/addons/parse-encoding/test.js
index 1456115a926f3e..da52f2dc4248af 100644
--- a/test/addons/parse-encoding/test.js
+++ b/test/addons/parse-encoding/test.js
@@ -8,6 +8,7 @@ assert.strictEqual(parseEncoding(''), 'UNKNOWN');
 
 assert.strictEqual(parseEncoding('ascii'), 'ASCII');
 assert.strictEqual(parseEncoding('base64'), 'BASE64');
+assert.strictEqual(parseEncoding('base64url'), 'BASE64URL');
 assert.strictEqual(parseEncoding('binary'), 'LATIN1');
 assert.strictEqual(parseEncoding('buffer'), 'BUFFER');
 assert.strictEqual(parseEncoding('hex'), 'HEX');
diff --git a/test/cctest/test_base64.cc b/test/cctest/test_base64.cc
index e92498da61b871..167e5e27bb05fe 100644
--- a/test/cctest/test_base64.cc
+++ b/test/cctest/test_base64.cc
@@ -44,6 +44,20 @@ TEST(Base64Test, Encode) {
        "IGRlc2VydW50IG1vbGxpdCBhbmltIGlkIGVzdCBsYWJvcnVtLg==");
 }
 
+TEST(Base64Test, EncodeURL) {
+  auto test = [](const char* string, const char* base64_string) {
+    const size_t len = strlen(base64_string);
+    char* const buffer = new char[len + 1];
+    buffer[len] = 0;
+    base64_encode(string, strlen(string), buffer, len, node::Base64Mode::URL);
+    EXPECT_STREQ(base64_string, buffer);
+    delete[] buffer;
+  };
+
+  test("\x68\xd9\x16\x25\x5c\x1e\x40\x92\x2d\xfb", "aNkWJVweQJIt-w");
+  test("\xac\xc7\x93\xaa\x83\x6f\xc3\xe3\x3f\x75", "rMeTqoNvw-M_dQ");
+}
+
 TEST(Base64Test, Decode) {
   auto test = [](const char* base64_string, const char* string) {
     const size_t len = strlen(string);
@@ -75,6 +89,7 @@ TEST(Base64Test, Decode) {
   test("YWJj ZGVm", "abcdef");
   test("Y W J j Z G V m", "abcdef");
   test("Y   W\n JjZ \nG Vm", "abcdef");
+  test("rMeTqoNvw-M_dQ", "\xac\xc7\x93\xaa\x83\x6f\xc3\xe3\x3f\x75");
 
   const char* text =
       "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do "
diff --git a/test/parallel/test-buffer-alloc.js b/test/parallel/test-buffer-alloc.js
index 070a3803802e56..d07d15125bc546 100644
--- a/test/parallel/test-buffer-alloc.js
+++ b/test/parallel/test-buffer-alloc.js
@@ -292,14 +292,40 @@ Buffer.alloc(1).write('', 1, 0);
 // Test toString('base64')
 //
 assert.strictEqual((Buffer.from('Man')).toString('base64'), 'TWFu');
+assert.strictEqual((Buffer.from('Woman')).toString('base64'), 'V29tYW4=');
+
+//
+// Test toString('base64url')
+//
+assert.strictEqual((Buffer.from('Man')).toString('base64url'), 'TWFu');
+assert.strictEqual((Buffer.from('Woman')).toString('base64url'), 'V29tYW4');
 
 {
-  // Test that regular and URL-safe base64 both work
+  // Test that regular and URL-safe base64 both work both ways
   const expected = [0xff, 0xff, 0xbe, 0xff, 0xef, 0xbf, 0xfb, 0xef, 0xff];
   assert.deepStrictEqual(Buffer.from('//++/++/++//', 'base64'),
                          Buffer.from(expected));
   assert.deepStrictEqual(Buffer.from('__--_--_--__', 'base64'),
                          Buffer.from(expected));
+  assert.deepStrictEqual(Buffer.from('//++/++/++//', 'base64url'),
+                         Buffer.from(expected));
+  assert.deepStrictEqual(Buffer.from('__--_--_--__', 'base64url'),
+                         Buffer.from(expected));
+}
+
+const base64flavors = ['base64', 'base64url'];
+
+{
+  // Test that regular and URL-safe base64 both work both ways with padding
+  const expected = [0xff, 0xff, 0xbe, 0xff, 0xef, 0xbf, 0xfb, 0xef, 0xff, 0xfb];
+  assert.deepStrictEqual(Buffer.from('//++/++/++//+w==', 'base64'),
+                         Buffer.from(expected));
+  assert.deepStrictEqual(Buffer.from('//++/++/++//+w==', 'base64'),
+                         Buffer.from(expected));
+  assert.deepStrictEqual(Buffer.from('//++/++/++//+w==', 'base64url'),
+                         Buffer.from(expected));
+  assert.deepStrictEqual(Buffer.from('//++/++/++//+w==', 'base64url'),
+                         Buffer.from(expected));
 }
 
 {
@@ -316,137 +342,182 @@ assert.strictEqual((Buffer.from('Man')).toString('base64'), 'TWFu');
                    'dWVkIGFuZCBpbmRlZmF0aWdhYmxlIGdlbmVyYXRpb24gb2Yga25vd2xlZ' +
                    'GdlLCBleGNlZWRzIHRoZSBzaG9ydCB2ZWhlbWVuY2Ugb2YgYW55IGNhcm' +
                    '5hbCBwbGVhc3VyZS4=';
-  assert.strictEqual((Buffer.from(quote)).toString('base64'), expected);
-
-  let b = Buffer.allocUnsafe(1024);
-  let bytesWritten = b.write(expected, 0, 'base64');
-  assert.strictEqual(quote.length, bytesWritten);
-  assert.strictEqual(quote, b.toString('ascii', 0, quote.length));
-
-  // Check that the base64 decoder ignores whitespace
-  const expectedWhite = `${expected.slice(0, 60)} \n` +
-                        `${expected.slice(60, 120)} \n` +
-                        `${expected.slice(120, 180)} \n` +
-                        `${expected.slice(180, 240)} \n` +
-                        `${expected.slice(240, 300)}\n` +
-                        `${expected.slice(300, 360)}\n`;
-  b = Buffer.allocUnsafe(1024);
-  bytesWritten = b.write(expectedWhite, 0, 'base64');
-  assert.strictEqual(quote.length, bytesWritten);
-  assert.strictEqual(quote, b.toString('ascii', 0, quote.length));
-
-  // Check that the base64 decoder on the constructor works
-  // even in the presence of whitespace.
-  b = Buffer.from(expectedWhite, 'base64');
-  assert.strictEqual(quote.length, b.length);
-  assert.strictEqual(quote, b.toString('ascii', 0, quote.length));
-
-  // Check that the base64 decoder ignores illegal chars
-  const expectedIllegal = expected.slice(0, 60) + ' \x80' +
-                          expected.slice(60, 120) + ' \xff' +
-                          expected.slice(120, 180) + ' \x00' +
-                          expected.slice(180, 240) + ' \x98' +
-                          expected.slice(240, 300) + '\x03' +
-                          expected.slice(300, 360);
-  b = Buffer.from(expectedIllegal, 'base64');
-  assert.strictEqual(quote.length, b.length);
-  assert.strictEqual(quote, b.toString('ascii', 0, quote.length));
+  assert.strictEqual(Buffer.from(quote).toString('base64'), expected);
+  assert.strictEqual(
+    Buffer.from(quote).toString('base64url'),
+    expected.replace(/\+/g, '-').replace(/\//g, '_').replace(/=/g, '')
+  );
+
+  base64flavors.forEach((encoding) => {
+    let b = Buffer.allocUnsafe(1024);
+    let bytesWritten = b.write(expected, 0, encoding);
+    assert.strictEqual(quote.length, bytesWritten);
+    assert.strictEqual(quote, b.toString('ascii', 0, quote.length));
+
+    // Check that the base64 decoder ignores whitespace
+    const expectedWhite = `${expected.slice(0, 60)} \n` +
+                          `${expected.slice(60, 120)} \n` +
+                          `${expected.slice(120, 180)} \n` +
+                          `${expected.slice(180, 240)} \n` +
+                          `${expected.slice(240, 300)}\n` +
+                          `${expected.slice(300, 360)}\n`;
+    b = Buffer.allocUnsafe(1024);
+    bytesWritten = b.write(expectedWhite, 0, encoding);
+    assert.strictEqual(quote.length, bytesWritten);
+    assert.strictEqual(quote, b.toString('ascii', 0, quote.length));
+
+    // Check that the base64 decoder on the constructor works
+    // even in the presence of whitespace.
+    b = Buffer.from(expectedWhite, encoding);
+    assert.strictEqual(quote.length, b.length);
+    assert.strictEqual(quote, b.toString('ascii', 0, quote.length));
+
+    // Check that the base64 decoder ignores illegal chars
+    const expectedIllegal = expected.slice(0, 60) + ' \x80' +
+                            expected.slice(60, 120) + ' \xff' +
+                            expected.slice(120, 180) + ' \x00' +
+                            expected.slice(180, 240) + ' \x98' +
+                            expected.slice(240, 300) + '\x03' +
+                            expected.slice(300, 360);
+    b = Buffer.from(expectedIllegal, encoding);
+    assert.strictEqual(quote.length, b.length);
+    assert.strictEqual(quote, b.toString('ascii', 0, quote.length));
+  });
 }
 
-assert.strictEqual(Buffer.from('', 'base64').toString(), '');
-assert.strictEqual(Buffer.from('K', 'base64').toString(), '');
-
-// multiple-of-4 with padding
-assert.strictEqual(Buffer.from('Kg==', 'base64').toString(), '*');
-assert.strictEqual(Buffer.from('Kio=', 'base64').toString(), '*'.repeat(2));
-assert.strictEqual(Buffer.from('Kioq', 'base64').toString(), '*'.repeat(3));
-assert.strictEqual(Buffer.from('KioqKg==', 'base64').toString(), '*'.repeat(4));
-assert.strictEqual(Buffer.from('KioqKio=', 'base64').toString(), '*'.repeat(5));
-assert.strictEqual(Buffer.from('KioqKioq', 'base64').toString(), '*'.repeat(6));
-assert.strictEqual(Buffer.from('KioqKioqKg==', 'base64').toString(),
-                   '*'.repeat(7));
-assert.strictEqual(Buffer.from('KioqKioqKio=', 'base64').toString(),
-                   '*'.repeat(8));
-assert.strictEqual(Buffer.from('KioqKioqKioq', 'base64').toString(),
-                   '*'.repeat(9));
-assert.strictEqual(Buffer.from('KioqKioqKioqKg==', 'base64').toString(),
-                   '*'.repeat(10));
-assert.strictEqual(Buffer.from('KioqKioqKioqKio=', 'base64').toString(),
-                   '*'.repeat(11));
-assert.strictEqual(Buffer.from('KioqKioqKioqKioq', 'base64').toString(),
-                   '*'.repeat(12));
-assert.strictEqual(Buffer.from('KioqKioqKioqKioqKg==', 'base64').toString(),
-                   '*'.repeat(13));
-assert.strictEqual(Buffer.from('KioqKioqKioqKioqKio=', 'base64').toString(),
-                   '*'.repeat(14));
-assert.strictEqual(Buffer.from('KioqKioqKioqKioqKioq', 'base64').toString(),
-                   '*'.repeat(15));
-assert.strictEqual(Buffer.from('KioqKioqKioqKioqKioqKg==', 'base64').toString(),
-                   '*'.repeat(16));
-assert.strictEqual(Buffer.from('KioqKioqKioqKioqKioqKio=', 'base64').toString(),
-                   '*'.repeat(17));
-assert.strictEqual(Buffer.from('KioqKioqKioqKioqKioqKioq', 'base64').toString(),
-                   '*'.repeat(18));
-assert.strictEqual(Buffer.from('KioqKioqKioqKioqKioqKioqKg==',
-                               'base64').toString(),
-                   '*'.repeat(19));
-assert.strictEqual(Buffer.from('KioqKioqKioqKioqKioqKioqKio=',
-                               'base64').toString(),
-                   '*'.repeat(20));
-
-// No padding, not a multiple of 4
-assert.strictEqual(Buffer.from('Kg', 'base64').toString(), '*');
-assert.strictEqual(Buffer.from('Kio', 'base64').toString(), '*'.repeat(2));
-assert.strictEqual(Buffer.from('KioqKg', 'base64').toString(), '*'.repeat(4));
-assert.strictEqual(Buffer.from('KioqKio', 'base64').toString(), '*'.repeat(5));
-assert.strictEqual(Buffer.from('KioqKioqKg', 'base64').toString(),
-                   '*'.repeat(7));
-assert.strictEqual(Buffer.from('KioqKioqKio', 'base64').toString(),
-                   '*'.repeat(8));
-assert.strictEqual(Buffer.from('KioqKioqKioqKg', 'base64').toString(),
-                   '*'.repeat(10));
-assert.strictEqual(Buffer.from('KioqKioqKioqKio', 'base64').toString(),
-                   '*'.repeat(11));
-assert.strictEqual(Buffer.from('KioqKioqKioqKioqKg', 'base64').toString(),
-                   '*'.repeat(13));
-assert.strictEqual(Buffer.from('KioqKioqKioqKioqKio', 'base64').toString(),
-                   '*'.repeat(14));
-assert.strictEqual(Buffer.from('KioqKioqKioqKioqKioqKg', 'base64').toString(),
-                   '*'.repeat(16));
-assert.strictEqual(Buffer.from('KioqKioqKioqKioqKioqKio', 'base64').toString(),
-                   '*'.repeat(17));
-assert.strictEqual(Buffer.from('KioqKioqKioqKioqKioqKioqKg',
-                               'base64').toString(),
-                   '*'.repeat(19));
-assert.strictEqual(Buffer.from('KioqKioqKioqKioqKioqKioqKio',
-                               'base64').toString(),
-                   '*'.repeat(20));
+base64flavors.forEach((encoding) => {
+  assert.strictEqual(Buffer.from('', encoding).toString(), '');
+  assert.strictEqual(Buffer.from('K', encoding).toString(), '');
+
+  // multiple-of-4 with padding
+  assert.strictEqual(Buffer.from('Kg==', encoding).toString(), '*');
+  assert.strictEqual(Buffer.from('Kio=', encoding).toString(), '*'.repeat(2));
+  assert.strictEqual(Buffer.from('Kioq', encoding).toString(), '*'.repeat(3));
+  assert.strictEqual(
+    Buffer.from('KioqKg==', encoding).toString(), '*'.repeat(4));
+  assert.strictEqual(
+    Buffer.from('KioqKio=', encoding).toString(), '*'.repeat(5));
+  assert.strictEqual(
+    Buffer.from('KioqKioq', encoding).toString(), '*'.repeat(6));
+  assert.strictEqual(Buffer.from('KioqKioqKg==', encoding).toString(),
+                     '*'.repeat(7));
+  assert.strictEqual(Buffer.from('KioqKioqKio=', encoding).toString(),
+                     '*'.repeat(8));
+  assert.strictEqual(Buffer.from('KioqKioqKioq', encoding).toString(),
+                     '*'.repeat(9));
+  assert.strictEqual(Buffer.from('KioqKioqKioqKg==', encoding).toString(),
+                     '*'.repeat(10));
+  assert.strictEqual(Buffer.from('KioqKioqKioqKio=', encoding).toString(),
+                     '*'.repeat(11));
+  assert.strictEqual(Buffer.from('KioqKioqKioqKioq', encoding).toString(),
+                     '*'.repeat(12));
+  assert.strictEqual(Buffer.from('KioqKioqKioqKioqKg==', encoding).toString(),
+                     '*'.repeat(13));
+  assert.strictEqual(Buffer.from('KioqKioqKioqKioqKio=', encoding).toString(),
+                     '*'.repeat(14));
+  assert.strictEqual(Buffer.from('KioqKioqKioqKioqKioq', encoding).toString(),
+                     '*'.repeat(15));
+  assert.strictEqual(
+    Buffer.from('KioqKioqKioqKioqKioqKg==', encoding).toString(),
+    '*'.repeat(16));
+  assert.strictEqual(
+    Buffer.from('KioqKioqKioqKioqKioqKio=', encoding).toString(),
+    '*'.repeat(17));
+  assert.strictEqual(
+    Buffer.from('KioqKioqKioqKioqKioqKioq', encoding).toString(),
+    '*'.repeat(18));
+  assert.strictEqual(Buffer.from('KioqKioqKioqKioqKioqKioqKg==',
+                                 encoding).toString(),
+                     '*'.repeat(19));
+  assert.strictEqual(Buffer.from('KioqKioqKioqKioqKioqKioqKio=',
+                                 encoding).toString(),
+                     '*'.repeat(20));
+
+  // No padding, not a multiple of 4
+  assert.strictEqual(Buffer.from('Kg', encoding).toString(), '*');
+  assert.strictEqual(Buffer.from('Kio', encoding).toString(), '*'.repeat(2));
+  assert.strictEqual(Buffer.from('KioqKg', encoding).toString(), '*'.repeat(4));
+  assert.strictEqual(
+    Buffer.from('KioqKio', encoding).toString(), '*'.repeat(5));
+  assert.strictEqual(Buffer.from('KioqKioqKg', encoding).toString(),
+                     '*'.repeat(7));
+  assert.strictEqual(Buffer.from('KioqKioqKio', encoding).toString(),
+                     '*'.repeat(8));
+  assert.strictEqual(Buffer.from('KioqKioqKioqKg', encoding).toString(),
+                     '*'.repeat(10));
+  assert.strictEqual(Buffer.from('KioqKioqKioqKio', encoding).toString(),
+                     '*'.repeat(11));
+  assert.strictEqual(Buffer.from('KioqKioqKioqKioqKg', encoding).toString(),
+                     '*'.repeat(13));
+  assert.strictEqual(Buffer.from('KioqKioqKioqKioqKio', encoding).toString(),
+                     '*'.repeat(14));
+  assert.strictEqual(Buffer.from('KioqKioqKioqKioqKioqKg', encoding).toString(),
+                     '*'.repeat(16));
+  assert.strictEqual(
+    Buffer.from('KioqKioqKioqKioqKioqKio', encoding).toString(),
+    '*'.repeat(17));
+  assert.strictEqual(
+    Buffer.from('KioqKioqKioqKioqKioqKioqKg', encoding).toString(),
+    '*'.repeat(19));
+  assert.strictEqual(
+    Buffer.from('KioqKioqKioqKioqKioqKioqKio', encoding).toString(),
+    '*'.repeat(20));
+});
 
 // Handle padding graciously, multiple-of-4 or not
 assert.strictEqual(
   Buffer.from('72INjkR5fchcxk9+VgdGPFJDxUBFR5/rMFsghgxADiw==', 'base64').length,
   32
 );
+assert.strictEqual(
+  Buffer.from('72INjkR5fchcxk9-VgdGPFJDxUBFR5_rMFsghgxADiw==', 'base64url')
+    .length,
+  32
+);
 assert.strictEqual(
   Buffer.from('72INjkR5fchcxk9+VgdGPFJDxUBFR5/rMFsghgxADiw=', 'base64').length,
   32
 );
+assert.strictEqual(
+  Buffer.from('72INjkR5fchcxk9-VgdGPFJDxUBFR5_rMFsghgxADiw=', 'base64url')
+    .length,
+  32
+);
 assert.strictEqual(
   Buffer.from('72INjkR5fchcxk9+VgdGPFJDxUBFR5/rMFsghgxADiw', 'base64').length,
   32
 );
+assert.strictEqual(
+  Buffer.from('72INjkR5fchcxk9-VgdGPFJDxUBFR5_rMFsghgxADiw', 'base64url')
+    .length,
+  32
+);
 assert.strictEqual(
   Buffer.from('w69jACy6BgZmaFvv96HG6MYksWytuZu3T1FvGnulPg==', 'base64').length,
   31
 );
+assert.strictEqual(
+  Buffer.from('w69jACy6BgZmaFvv96HG6MYksWytuZu3T1FvGnulPg==', 'base64url')
+    .length,
+  31
+);
 assert.strictEqual(
   Buffer.from('w69jACy6BgZmaFvv96HG6MYksWytuZu3T1FvGnulPg=', 'base64').length,
   31
 );
+assert.strictEqual(
+  Buffer.from('w69jACy6BgZmaFvv96HG6MYksWytuZu3T1FvGnulPg=', 'base64url')
+    .length,
+  31
+);
 assert.strictEqual(
   Buffer.from('w69jACy6BgZmaFvv96HG6MYksWytuZu3T1FvGnulPg', 'base64').length,
   31
 );
+assert.strictEqual(
+  Buffer.from('w69jACy6BgZmaFvv96HG6MYksWytuZu3T1FvGnulPg', 'base64url').length,
+  31
+);
 
 {
 // This string encodes single '.' character in UTF-16
@@ -458,6 +529,16 @@ assert.strictEqual(
   assert.strictEqual(dot.toString('base64'), '//4uAA==');
 }
 
+{
+// This string encodes single '.' character in UTF-16
+  const dot = Buffer.from('//4uAA', 'base64url');
+  assert.strictEqual(dot[0], 0xff);
+  assert.strictEqual(dot[1], 0xfe);
+  assert.strictEqual(dot[2], 0x2e);
+  assert.strictEqual(dot[3], 0x00);
+  assert.strictEqual(dot.toString('base64url'), '__4uAA');
+}
+
 {
   // Writing base64 at a position > 0 should not mangle the result.
   //
@@ -473,6 +554,21 @@ assert.strictEqual(
                      'Madness?! This is node.js!');
 }
 
+{
+  // Writing base64url at a position > 0 should not mangle the result.
+  //
+  // https://github.com/joyent/node/issues/402
+  const segments = ['TWFkbmVzcz8h', 'IFRoaXM', 'IGlz', 'IG5vZGUuanMh'];
+  const b = Buffer.allocUnsafe(64);
+  let pos = 0;
+
+  for (let i = 0; i < segments.length; ++i) {
+    pos += b.write(segments[i], pos, 'base64url');
+  }
+  assert.strictEqual(b.toString('latin1', 0, pos),
+                     'Madness?! This is node.js!');
+}
+
 // Regression test for https://github.com/nodejs/node/issues/3496.
 assert.strictEqual(Buffer.from('=bad'.repeat(1e4), 'base64').length, 0);
 
diff --git a/test/parallel/test-buffer-bytelength.js b/test/parallel/test-buffer-bytelength.js
index b5264ba092ce1e..2355e4e0a0b442 100644
--- a/test/parallel/test-buffer-bytelength.js
+++ b/test/parallel/test-buffer-bytelength.js
@@ -91,9 +91,19 @@ assert.strictEqual(Buffer.byteLength('aGkk', 'base64'), 3);
 assert.strictEqual(
   Buffer.byteLength('bHNrZGZsa3NqZmtsc2xrZmFqc2RsZmtqcw==', 'base64'), 25
 );
+// base64url
+assert.strictEqual(Buffer.byteLength('aGVsbG8gd29ybGQ', 'base64url'), 11);
+assert.strictEqual(Buffer.byteLength('aGVsbG8gd29ybGQ', 'BASE64URL'), 11);
+assert.strictEqual(Buffer.byteLength('bm9kZS5qcyByb2NrcyE', 'base64url'), 14);
+assert.strictEqual(Buffer.byteLength('aGkk', 'base64url'), 3);
+assert.strictEqual(
+  Buffer.byteLength('bHNrZGZsa3NqZmtsc2xrZmFqc2RsZmtqcw', 'base64url'), 25
+);
 // special padding
 assert.strictEqual(Buffer.byteLength('aaa=', 'base64'), 2);
 assert.strictEqual(Buffer.byteLength('aaaa==', 'base64'), 3);
+assert.strictEqual(Buffer.byteLength('aaa=', 'base64url'), 2);
+assert.strictEqual(Buffer.byteLength('aaaa==', 'base64url'), 3);
 
 assert.strictEqual(Buffer.byteLength('Il était tué'), 14);
 assert.strictEqual(Buffer.byteLength('Il était tué', 'utf8'), 14);
diff --git a/test/parallel/test-buffer-fill.js b/test/parallel/test-buffer-fill.js
index 6e24b3511e6e1a..6e7b24989a53bb 100644
--- a/test/parallel/test-buffer-fill.js
+++ b/test/parallel/test-buffer-fill.js
@@ -131,20 +131,36 @@ assert.throws(() => {
 });
 
 // BASE64
-testBufs('YWJj', 'ucs2');
-testBufs('yKJhYQ==', 'ucs2');
-testBufs('Yci0Ysi1Y8i2', 'ucs2');
-testBufs('YWJj', 4, 'ucs2');
-testBufs('YWJj', SIZE, 'ucs2');
-testBufs('yKJhYQ==', 2, 'ucs2');
-testBufs('yKJhYQ==', 8, 'ucs2');
-testBufs('Yci0Ysi1Y8i2', 4, 'ucs2');
-testBufs('Yci0Ysi1Y8i2', 12, 'ucs2');
-testBufs('YWJj', 4, 1, 'ucs2');
-testBufs('YWJj', 5, 1, 'ucs2');
-testBufs('yKJhYQ==', 8, 1, 'ucs2');
-testBufs('Yci0Ysi1Y8i2', 4, 1, 'ucs2');
-testBufs('Yci0Ysi1Y8i2', 12, 1, 'ucs2');
+testBufs('YWJj', 'base64');
+testBufs('yKJhYQ==', 'base64');
+testBufs('Yci0Ysi1Y8i2', 'base64');
+testBufs('YWJj', 4, 'base64');
+testBufs('YWJj', SIZE, 'base64');
+testBufs('yKJhYQ==', 2, 'base64');
+testBufs('yKJhYQ==', 8, 'base64');
+testBufs('Yci0Ysi1Y8i2', 4, 'base64');
+testBufs('Yci0Ysi1Y8i2', 12, 'base64');
+testBufs('YWJj', 4, 1, 'base64');
+testBufs('YWJj', 5, 1, 'base64');
+testBufs('yKJhYQ==', 8, 1, 'base64');
+testBufs('Yci0Ysi1Y8i2', 4, 1, 'base64');
+testBufs('Yci0Ysi1Y8i2', 12, 1, 'base64');
+
+// BASE64URL
+testBufs('YWJj', 'base64url');
+testBufs('yKJhYQ', 'base64url');
+testBufs('Yci0Ysi1Y8i2', 'base64url');
+testBufs('YWJj', 4, 'base64url');
+testBufs('YWJj', SIZE, 'base64url');
+testBufs('yKJhYQ', 2, 'base64url');
+testBufs('yKJhYQ', 8, 'base64url');
+testBufs('Yci0Ysi1Y8i2', 4, 'base64url');
+testBufs('Yci0Ysi1Y8i2', 12, 'base64url');
+testBufs('YWJj', 4, 1, 'base64url');
+testBufs('YWJj', 5, 1, 'base64url');
+testBufs('yKJhYQ', 8, 1, 'base64url');
+testBufs('Yci0Ysi1Y8i2', 4, 1, 'base64url');
+testBufs('Yci0Ysi1Y8i2', 12, 1, 'base64url');
 
 // Buffer
 function deepStrictEqualValues(buf, arr) {
diff --git a/test/parallel/test-buffer-isencoding.js b/test/parallel/test-buffer-isencoding.js
index e67d1c078397a3..1a9e17dc48714d 100644
--- a/test/parallel/test-buffer-isencoding.js
+++ b/test/parallel/test-buffer-isencoding.js
@@ -11,6 +11,7 @@ const assert = require('assert');
   'latin1',
   'binary',
   'base64',
+  'base64url',
   'ucs2',
   'ucs-2',
   'utf16le',
diff --git a/test/parallel/test-buffer-write.js b/test/parallel/test-buffer-write.js
index 842b12c04c04db..3a4a3a8b696612 100644
--- a/test/parallel/test-buffer-write.js
+++ b/test/parallel/test-buffer-write.js
@@ -23,6 +23,7 @@ const resultMap = new Map([
   ['binary', Buffer.from([102, 111, 111, 0, 0, 0, 0, 0, 0])],
   ['utf16le', Buffer.from([102, 0, 111, 0, 111, 0, 0, 0, 0])],
   ['base64', Buffer.from([102, 111, 111, 0, 0, 0, 0, 0, 0])],
+  ['base64url', Buffer.from([102, 111, 111, 0, 0, 0, 0, 0, 0])],
   ['hex', Buffer.from([102, 111, 111, 0, 0, 0, 0, 0, 0])]
 ]);
 
@@ -44,7 +45,7 @@ encodings
   });
 
 // base64
-['base64', 'BASE64'].forEach((encoding) => {
+['base64', 'BASE64', 'base64url', 'BASE64URL'].forEach((encoding) => {
   const buf = Buffer.alloc(9);
   const len = Buffer.byteLength('Zm9v', encoding);
 
diff --git a/test/parallel/test-internal-util-normalizeencoding.js b/test/parallel/test-internal-util-normalizeencoding.js
index d7a0259ac9c9fd..af567cbcf5cab3 100644
--- a/test/parallel/test-internal-util-normalizeencoding.js
+++ b/test/parallel/test-internal-util-normalizeencoding.js
@@ -33,6 +33,9 @@ const tests = [
   ['base64', 'base64'],
   ['BASE64', 'base64'],
   ['Base64', 'base64'],
+  ['base64url', 'base64url'],
+  ['BASE64url', 'base64url'],
+  ['Base64url', 'base64url'],
   ['hex', 'hex'],
   ['HEX', 'hex'],
   ['ASCII', 'ascii'],
diff --git a/test/parallel/test-string-decoder-end.js b/test/parallel/test-string-decoder-end.js
index ee0a47e3572f6d..5a3c5cc720789d 100644
--- a/test/parallel/test-string-decoder-end.js
+++ b/test/parallel/test-string-decoder-end.js
@@ -27,7 +27,7 @@
 require('../common');
 const assert = require('assert');
 const SD = require('string_decoder').StringDecoder;
-const encodings = ['base64', 'hex', 'utf8', 'utf16le', 'ucs2'];
+const encodings = ['base64', 'base64url', 'hex', 'utf8', 'utf16le', 'ucs2'];
 
 const bufs = [ '☃💩', 'asdf' ].map((b) => Buffer.from(b));
 
@@ -79,6 +79,13 @@ testEnd('base64', Buffer.of(0x61, 0x61), Buffer.of(0x61), 'YWE=YQ==');
 testEnd('base64', Buffer.of(0x61, 0x61, 0x61), Buffer.of(), 'YWFh');
 testEnd('base64', Buffer.of(0x61, 0x61, 0x61), Buffer.of(0x61), 'YWFhYQ==');
 
+testEnd('base64url', Buffer.of(0x61), Buffer.of(), 'YQ');
+testEnd('base64url', Buffer.of(0x61), Buffer.of(0x61), 'YQYQ');
+testEnd('base64url', Buffer.of(0x61, 0x61), Buffer.of(), 'YWE');
+testEnd('base64url', Buffer.of(0x61, 0x61), Buffer.of(0x61), 'YWEYQ');
+testEnd('base64url', Buffer.of(0x61, 0x61, 0x61), Buffer.of(), 'YWFh');
+testEnd('base64url', Buffer.of(0x61, 0x61, 0x61), Buffer.of(0x61), 'YWFhYQ');
+
 function testEncoding(encoding) {
   bufs.forEach((buf) => {
     testBuf(encoding, buf);
diff --git a/test/parallel/test-string-decoder-fuzz.js b/test/parallel/test-string-decoder-fuzz.js
index d8d01881591161..ac6f74e94981a8 100644
--- a/test/parallel/test-string-decoder-fuzz.js
+++ b/test/parallel/test-string-decoder-fuzz.js
@@ -20,7 +20,7 @@ function randBuf(maxLen) {
 }
 
 const encodings = [
-  'utf16le', 'utf8', 'ascii', 'hex', 'base64', 'latin1'
+  'utf16le', 'utf8', 'ascii', 'hex', 'base64', 'latin1', 'base64url'
 ];
 
 function runSingleFuzzTest() {