This article presents a range of Base64 encoding and decoding examples in JavaScript. Additionally, we demonstrate the implementation of base64url in Python. Beyond that, we provide readily usable Base64 samples that facilitate quick and efficient testing of code accuracy.
,

Simple Base64 Code Examples and Samples For Testing

The following article provides a variety of JavaScript Base64 encoding and decoding examples. In addition, we show how to implement Base64URL in Python. In addition, we supply easily useable Base64 examples, which allow for quick and efficient assessment of code accuracy.

Example of Base64 Encoding in JavaScript

Let’s look at a basic example to see how the btoa() method in JavaScript works for Base64 encoding.

Assume you have a string that says, “Hello, World!” to encode this string with btoa(), provide it to the function as an argument:

// Declare a variable to hold the original string
const originalString = Hello, World!;   // Use the btoa() function to encode the original string in Base64
const encodedString = btoa(originalString);   // Output: "SGVsbG8sIFdvcmxkIQ"
console.log(encodedString);

The resulting encodedString will contain the Base64-encoded version of the original string:

SGVsbG8sIFdvcmxkIQ==

And there you have it, the Base64 encoded string.

Online Base64 Encoder

Example of Converting Files/Images to Base64 in JavaScript

Converting files to Base64 encoding is a common process in web development, and it is commonly used for applications like AJAX file uploads or embedding images directly into HTML. Let’s look at a simple JavaScript sample to see how this process works.

Base64 in JavaScript Infographic: btoa() and atob() functions

Assume you have a “image.png” picture file that you want to convert to Base64 format. Here’s how you do it with the FileReader API and the btoa() function:

// Select the input element where the user uploads the file const input = document.querySelector(‘input[type="file"]’);   // Listen for the ‘change’ event when a file is selected input.addEventListener(‘change’, (event) => { const file = event.target.files[0];   // Use FileReader to read the file as a Data URL const reader = new FileReader(); reader.onload = (readerEvent) => { const dataURL = readerEvent.target.result;   // Remove the "data:image/png;base64," prefix const base64Data = dataURL.split(‘,’)[1];   // Encode the Base64 data const encodedData = btoa(base64Data);   // Now ‘encodedData’ contains the Base64-encoded file data };   // Read the file as a Data URL reader.readAsDataURL(file); });

Here is what happens in the code above:

  1. The input variable is assigned the result of calling document.querySelector() with the argument 'input[type="file"]'. This selects the <input type="file"> element on the page.
  2. When the user picks a file, an event listener is attached to the input element to listen for the ‘change’ event.
  3. When the 'change' event is triggered, the first file in the event.target.files array is assigned to the file variable.
  4. The reader variable is assigned a new FileReader object that is created.
  5. An event listener is added to the reader object to listen for the 'load' event, which is triggered when the file has been read as a Data URL.
  6. When the 'load' event is triggered, the result of reading the file as a Data URL is assigned to the dataURL variable.
  7. The "data:image/png;base64," prefix is removed from the dataURL by calling .split(',')[1], and the result is assigned to the base64Data variable.
  8. The base64Data variable is then passed as an argument to the btoa() function, which encodes it in Base64 and returns the result. This result is assigned to the encodedData variable.
  9. Finally, the reader.readAsDataURL() method is called with the file variable as an argument, which starts reading the file as a Data URL.

Example of Base64 Decoding in JavaScript

Let’s use a simple example to demonstrate the process of Base64 decoding with the atob() function.

Assume you have the following Base64-encoded string: “SGVsbG8sIFdvcmxkIQ==“, which corresponds to the original string “Hello, World!” You may use the atob() method to decode this Base64-encoded text and obtain the original data:

// Declare a variable to hold the Base64-encoded string const encodedString = "SGVsbG8sIFdvcmxkIQ==";   // Use the atob() function to decode the Base64-encoded string const decodedString = atob(encodedString);   // Log the decoded string to the console console.log(decodedString); // Output: Hello, World!
Online Base64 Decoder

Decoding Base64 to File/Image in JavaScript

Decoding Base64-encoded data back to its original file or image format is a common web development procedure, and it is commonly used when dealing with file uploads or retrieving embedded pictures. Let’s look at an example that shows how to use JavaScript to decode a Base64-encoded image and display it on a webpage.

Assume you have a Base64-encoded image string and wish to display it on an HTML element with the ID “image-container“:

// This is our Base64 Image const encodedImage = "R0lGODlhAQABAIAAAP///wAAACH5BAEAAAAALAAAAAABAAEAAAICRAEAOw==";   // Create a new image element const img = document.createElement("img");   // Set the source of the image to the decoded Base64 data img.src = "data:image/png;base64," + encodedImage;   // Append the image to the designated container const imageContainer = document.getElementById("image-container"); imageContainer.appendChild(img);

The following step-by-step guide explains the above code:

  1. A value representing a Base64-encoded image string is allocated to the encodedImage variable.
  2. A new <img> element is created by calling document.createElement("img") and the result is assigned to the img variable.
  3. The src attribute of the img element is set to a data URL that represents the decoded Base64 image data. This is done by concatenating the string "data:image/png;base64," with the value of the encodedImage variable.
  4. The imageContainer variable is assigned the result of calling document.getElementById("image-container"), which selects an element on the page with an id attribute of "image-container".
  5. The img element is appended to the imageContainer element as a child by calling imageContainer.appendChild(img).

How to Download Base64 File in JavaScript Example

If you need to download the Base64 content, don’t worry, you can easily do that in JavaScript. Assume you have a Base64-encoded file and want customers to be able to download it when they click the “download-button” button:

const encodedFile = "YjY0ZW5jb2RlLmNvbQ==";   // Select the download button element const downloadButton = document.getElementById("download-button");   // Add a click event listener to the button downloadButton.addEventListener("click", () => { // Create a new Blob from the decoded Base64 data const blob = new Blob([Uint8Array.from(atob(encodedFile), c => c.charCodeAt(0))]);   // Create a download URL for the Blob const downloadUrl = URL.createObjectURL(blob);   // Create a temporary link element const link = document.createElement("a"); link.href = downloadUrl; link.download = "downloaded-file.txt"; // Set the desired file name link.click();   // Clean up the URL and the temporary link URL.revokeObjectURL(downloadUrl); });

Detailed explanation of the above code:

  1. The encodedFile variable receives a value representing a Base64-encoded file.
  2. The downloadButton variable is assigned the result of calling document.getElementById("download-button"), which selects an element on the page with an id attribute of "download-button".
  3. When the user clicks the button, an event listener is attached to the downloadButton element to listen for the ‘click’ event.
  4. When the 'click' event is triggered, a new Blob object is created from the decoded Base64 data by calling new Blob([Uint8Array.from(atob(encodedFile), c => c.charCodeAt(0))]). This Blob object represents the contents of the file to be downloaded.
  5. A download URL for the Blob object is created by calling URL.createObjectURL(blob), and the result is assigned to the downloadUrl variable.
  6. A temporary <a> element is created by calling document.createElement("a"), and its href attribute is set to the value of the downloadUrl variable.
  7. The click() method of the <a> element is invoked, which starts the file download.
  8. The download URL is revoked by calling URL.revokeObjectURL(downloadUrl).
  9. The download attribute of the <a> element is set to "downloaded-file.txt", which specifies the desired file name for the downloaded file.

Base64URL in Python

Although most programming languages (including Python) do not natively offer Base64URL encoding and decoding, it is possible with minimal modifications. Let’s look at how this process works and give an example in a popular programming language.

Online Base64URL Encoder

In languages without built-in Base64URL support, you have to replace the characters “+” with “-“, “/” with “_”, and remove “=” padding characters to create a URL-safe character set.

Below you can see an example in Python:

import base64   def base64url_encode(data): # Encode the data using base64 encoded = base64.b64encode(data) # Replace characters that are not URL safe with URL safe characters url_safe_encoded = encoded.replace(b‘+’, b‘-‘).replace(b‘/’, b‘_’).rstrip(b‘=’) return url_safe_encoded   def base64url_decode(encoded): # Add padding if necessary padding = b‘=’ * (4 – (len(encoded) % 4)) # Replace URL safe characters with their original characters url_safe_encoded = encoded.replace(b‘-‘, b‘+’).replace(b‘_’, b‘/’) + padding # Decode the data using base64 decoded = base64.b64decode(url_safe_encoded) return decoded   # Example usage data_to_encode = b"Data to Encode." encoded_data = base64url_encode(data_to_encode) decoded_data = base64url_decode(encoded_data)   print("Original Data:", data_to_encode) print("Encoded Data:", encoded_data) print("Decoded Data:", decoded_data)

Base64 Samples

Below you will find ready-to-use Base64 samples that can be immediately utilized for testing purposes. These samples are categorized into various sections, including text, image, and audio. The audio file source can be found here.

Base64 codes are hidden by default due to their potentially long and compact nature. Clicking on their names reveals the full code.

But first we show a text example. DiMolnar looks like this when encoded in Base64: RGlNb2xuYXI=

Base64 Text Sample

TG9yZW0gaXBzdW0gZG9sb3Igc2l0IGFtZXQsIGNvbnNlY3RldHVyIGFkaXBpc2NpbmcgZWxpdCwgc2VkIGRvIGVpdXNtb2QgdGVtcG9yIGluY2lkaWR1bnQgdXQgbGFib3JlIGV0IGRvbG9yZSBtYWduYSBhbGlxdWEuIFV0IGVuaW0gYWQgbWluaW0gdmVuaWFtLCBxdWlzIG5vc3RydWQgZXhlcmNpdGF0aW9uIHVsbGFtY28gbGFib3JpcyBuaXNpIHV0IGFsaXF1aXAgZXggZWEgY29tbW9kbyBjb25zZXF1YXQuIER1aXMgYXV0ZSBpcnVyZSBkb2xvciBpbiByZXByZWhlbmRlcml0IGluIHZvbHVwdGF0ZSB2ZWxpdCBlc3NlIGNpbGx1bSBkb2xvcmUgZXUgZnVnaWF0IG51bGxhIHBhcmlhdHVyLiBFeGNlcHRldXIgc2ludCBvY2NhZWNhdCBjdXBpZGF0YXQgbm9uIHByb2lkZW50LCBzdW50IGluIGN1bHBhIHF1aSBvZmZpY2lhIGRlc2VydW50IG1vbGxpdCBhbmltIGlkIGVzdCBsYWJvcnVtLg

Base64 Image (PNG) Sample

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

Base64 Audio (MP3) Sample

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

Related Tools/Articles