Developer Tool

Base64 Encoder

Encode plain text into Base64 instantly in your browser. Fast, private, and supports Unicode text correctly.

Plain text 0 characters

Paste or type the text you want to encode.

Base64 output 0 characters

Your Base64 result appears here after encoding.

Ready to encode text locally in your browser.

How to Use

Enter or paste plain text into the input area.
Click Encode to generate the Base64 version instantly.
Use Copy Result to copy the output, or Clear to reset both fields.

What Is Base64 Encoding?

Base64 is a text-based encoding format that turns plain text into a safe ASCII format. It is commonly used in APIs, data URLs, email systems, tokens, and situations where data needs to travel through text-only channels.

Important: Base64 is not encryption. It changes the representation of data, but it does not secure or hide it.

Why Use This Tool

Handles UTF-8 text correctly, including Arabic and other non-English characters.
Runs directly in your browser, so the text is encoded locally on the page.
Keeps the workflow simple with clear input, instant output, and one-click copying.

Use Cases

Encoding text for API requests and payloads
Preparing data for JWT tokens and authentication
Creating Base64 data URIs for embedding in HTML
Quick encoding for email or data transmission

Frequently Asked Questions

Does this tool support Arabic and Unicode text?

Yes. This encoder uses UTF-8 safe handling before converting the text to Base64, so Arabic and other Unicode characters are encoded correctly.

Is Base64 the same as encryption?

No. Base64 is only an encoding format. Anyone can decode Base64 text back to its original form, so it should not be used to protect sensitive data.

Is my text sent anywhere?

No. This tool works entirely in your browser using JavaScript on the page.

Can I encode multi-line text, symbols, or code snippets?

Yes. Line breaks, punctuation, code, and general text content can all be encoded as long as they are entered into the input field.

Why is the Base64 output longer than the original text?

That is normal. Base64 expands the original data size because it converts the content into a text-safe format.

if (root.dataset.toolBound === “true”) {
  return;
}
root.dataset.toolBound = “true”;

var input = root.querySelector(‘[data-role=”input”]’);
var output = root.querySelector(‘[data-role=”output”]’);
var status = root.querySelector(‘[data-role=”status”]’);
var inputCount = root.querySelector(‘[data-role=”input-count”]’);
var outputCount = root.querySelector(‘[data-role=”output-count”]’);
var encodeButton = root.querySelector(‘[data-action=”encode”]’);
var copyButton = root.querySelector(‘[data-action=”copy”]’);
var clearButton = root.querySelector(‘[data-action=”clear”]’);

if (!input || !output || !encodeButton || !copyButton || !clearButton) {
  return;
}

function countCharacters(value) {
  return Array.from(value || “”).length;
}

function setStatus(message, state) {
  if (!status) return;
  status.textContent = message;
  status.setAttribute(“data-state”, state || “neutral”);
}

function encodeUtf8ToBase64(text) {
  var bytes = new TextEncoder().encode(text);
  var chunkSize = 0x8000;
  var binary = “”;

for (var i = 0; i < bytes.length; i += chunkSize) {
    var chunk = bytes.subarray(i, i + chunkSize);
    for (var j = 0; j < chunk.length; j += 1) {
      binary += String.fromCharCode(chunk[j]);
    }
  }

return btoa(binary);
}

function fallbackCopy(text) {
  var helper = document.createElement("textarea");
  helper.value = text;
  helper.setAttribute("readonly", "");
  helper.style.position = "fixed";
  helper.style.top = "0";
  helper.style.left = "0";
  helper.style.opacity = "0";
  helper.style.pointerEvents = "none";

document.body.appendChild(helper);
  helper.focus();
  helper.select();

var copied = false;
  try {
    copied = document.execCommand("copy");
  } finally {
    document.body.removeChild(helper);
  }

if (!copied) {
    throw new Error("Fallback copy failed.");
  }
}

async function copyText(text) {
  if (navigator.clipboard && window.isSecureContext) {
    await navigator.clipboard.writeText(text);
  } else {
    fallbackCopy(text);
  }
}

function handleEncode() {
  if (!input.value.length) {
    output.value = "";
    refresh();
    setStatus("Enter some text first, then click Encode.", "error");
    input.focus();
    return;
  }

try {
    output.value = encodeUtf8ToBase64(input.value);
    refresh();
    setStatus("Text encoded successfully.", "success");
  } catch (e) {
    output.value = "";
    refresh();
    setStatus("Encoding could not be completed. Please try again.", "error");
  }
}

async function handleCopy() {
  if (!output.value) {
    setStatus("There is no Base64 result to copy yet.", "error");
    return;
  }

try {
    await copyText(output.value);
    setStatus("Base64 result copied to the clipboard.", "success");
  } catch (e) {
    setStatus("Copy could not be completed. Please copy the result manually.", "error");
  }
}

function handleClear() {
  input.value = "";
  output.value = "";
  refresh();
  setStatus("Input and output cleared.", "neutral");
  input.focus();
}

encodeButton.addEventListener("click", handleEncode);
copyButton.addEventListener("click", handleCopy);
clearButton.addEventListener("click", handleClear);

input.addEventListener("input", function () {
  refresh();
  if (status && status.getAttribute("data-state") === "error" && input.value.length > 0) {
    setStatus(“Ready to encode text locally in your browser.”, “neutral”);
  }
});

input.addEventListener(“keydown”, function (event) {
  if ((event.ctrlKey || event.metaKey) && event.key === “Enter”) {
    event.preventDefault();
    handleEncode();
  }
});

refresh();