Du har förmodligen sett Base64-strängar utspridda i din kodbas — i JWT-tokens, HTML-taggar som <img>, HTTP Authorization-headers eller JSON-nyttolaster som bär fildata. De ser ut som nonsens: SGVsbG8sIFdvcmxkIQ==. Men det finns en enkel anledning till att de existerar, och när du förstår den slutar Base64 vara mystiskt och börjar bli ett genuint användbart verktyg i din verktygslåda.

Vad Base64 faktiskt är

Base64 är ett binärt-till-text kodningsschema. Det är allt. Det tar godtycklig binärdata — bytes som kan innehålla null-tecken, kontrollkoder eller vilket värde som helst från 0 till 255 — och representerar dem med bara 64 utskrivbara ASCII-tecken. Resultatet är en sträng som säkert kan färdas genom vilken textbaserad kanal som helst utan att bli korrupt eller feltolkad.

Den formella specifikationen finns i RFC 4648, publicerad av IETF. Den definierar både standard-Base64 och URL-säker variant. Värd att bokmärka om du någonsin behöver avgöra en diskussion om utfyllnadsregler eller alfabetsval.

Base64-alfabetet

64-teckensalfabetet består av: stora bokstäver A–Z (26 tecken), gemener a–z (26 tecken), siffror 0–9 (10 tecken), och två symboler: + och /. Det ger exakt 64 tecken — därav namnet. Tecknet = används som utfyllnadstecken i slutet när indatalängden inte är en multipel av 3.

text
ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/

Varje tecken kodar exakt 6 bitar data (2^6 = 64 möjliga värden). Det här är kärnmekanismen bakom kodningen — och orsaken till den ~33% storleksökning.

Hur kodningen fungerar

Algoritmen fungerar i bitar av 3 bytes → 4 Base64-tecken. Tre bytes = 24 bitar. Dela upp de 24 bitarna i fyra 6-bitarsgrupper, och varje grupp mappar till ett tecken i Base64-alfabetet.

text
Input:  "Man"
Bytes:  M=77 (01001101)  a=97 (01100001)  n=110 (01101110)
Bits:   010011 010110 000101 101110
Index:  19     22     5      46
Output: T      W      F      u     →  "TWFu"

När indata inte är delbart med 3 aktiveras utfyllnad. Två återstående bytes blir tre Base64-tecken plus ett =. En återstående byte blir två Base64-tecken plus ==. Utfyllnaden berättar bara för avkodaren hur många bytes som faktiskt finns i slutet — det är inte en del av själva datan.

Storleksökningskostnaden: varje 3 bytes indata blir 4 tecken i utdata. Det är en 33% storleksökning. För små strängar är det försumbart. För stora binära filer — en 10 MB bild blir ungefär 13,3 MB Base64 — spelar ökningen roll och du bör tänka efter innan du bäddar in direkt.

Kodning och avkodning i JavaScript

Webbläsare exponerar btoa() och atob() som globala variabler. De är enkla men har en fallgrop: de hanterar bara Latin-1-tecken (bytevärden 0–255). Skicka en multi-byte Unicode-sträng direkt så får du InvalidCharacterError.

js
// Basic browser encoding/decoding
const encoded = btoa('Hello, World!');  // "SGVsbG8sIFdvcmxkIQ=="
const decoded = atob('SGVsbG8sIFdvcmxkIQ==');  // "Hello, World!"

// Safe Unicode version — encode to UTF-8 first
function encodeUnicode(str) {
  return btoa(
    encodeURIComponent(str).replace(/%([0-9A-F]{2})/g, (_, hex) =>
      String.fromCharCode(parseInt(hex, 16))
    )
  );
}

function decodeUnicode(str) {
  return decodeURIComponent(
    atob(str)
      .split('')
      .map(c => '%' + c.charCodeAt(0).toString(16).padStart(2, '0'))
      .join('')
  );
}

const emoji = encodeUnicode('Héllo wörld 🌍');
console.log(emoji);                  // "SMOpbGxvIHfDtnJsZCDwn4yN"
console.log(decodeUnicode(emoji));   // "Héllo wörld 🌍"

Node.js — Använda Buffer

I Node.js är det idiomatiska tillvägagångssättet Buffer API, som hanterar Unicode korrekt från start och är mycket renare än webbläsarens lösning ovan.

js
// Encoding
const encoded = Buffer.from('Hello, World!', 'utf8').toString('base64');
console.log(encoded);  // "SGVsbG8sIFdvcmxkIQ=="

// Decoding
const decoded = Buffer.from('SGVsbG8sIFdvcmxkIQ==', 'base64').toString('utf8');
console.log(decoded);  // "Hello, World!"

// Encoding a file to Base64 (e.g. to embed in a JSON payload)
const fs = require('fs');

function fileToBase64(filePath) {
  const fileBuffer = fs.readFileSync(filePath);
  return fileBuffer.toString('base64');
}

function base64ToFile(base64String, outputPath) {
  const fileBuffer = Buffer.from(base64String, 'base64');
  fs.writeFileSync(outputPath, fileBuffer);
}

const avatarBase64 = fileToBase64('./uploads/avatar.png');
const payload = {
  userId: 'usr_8f3k2',
  avatarData: avatarBase64,
  mimeType: 'image/png'
};

Python — Modulen base64

Pythons standardbibliotek inkluderar en base64-modul som hanterar kodning, avkodning och URL-säker variant. Funktionerna arbetar med bytes-objekt, så du kodar/avkodar normalt strängar med en explicit teckenuppsättning.

python
import base64

# Encoding a string
message = "Hello, World!"
encoded = base64.b64encode(message.encode("utf-8"))
print(encoded)           # b'SGVsbG8sIFdvcmxkIQ=='
print(encoded.decode())  # 'SGVsbG8sIFdvcmxkIQ=='

# Decoding
decoded_bytes = base64.b64decode("SGVsbG8sIFdvcmxkIQ==")
print(decoded_bytes.decode("utf-8"))  # 'Hello, World!'

# Encoding a file
with open("report.pdf", "rb") as f:
    pdf_base64 = base64.b64encode(f.read()).decode("utf-8")

# Embedding it in a JSON-compatible structure
import json
payload = {
    "filename": "report.pdf",
    "content": pdf_base64,
    "encoding": "base64"
}
print(json.dumps(payload, indent=2))

URL-säker Base64

Standard-Base64 använder + och /, som är specialtecken i URL:er. Lägg en standard-Base64-sträng i en frågeparameter så får du subtil korruption om du inte procentkodar den först. URL-säker Base64 (definierad i RFC 4648 §5) löser detta genom att ersätta + med - och / med _. Utfyllnadstecken = utelämnas ofta helt i URL-sammanhang.

js
// Standard → URL-safe conversion in JavaScript
function toBase64Url(base64) {
  return base64
    .replace(/+/g, '-')
    .replace(///g, '_')
    .replace(/=+$/, '');  // strip padding
}

function fromBase64Url(base64url) {
  // Restore padding
  const padded = base64url + '=='.slice(0, (4 - (base64url.length % 4)) % 4);
  return padded.replace(/-/g, '+').replace(/_/g, '/');
}

const standard = btoa('some binary  data');
const urlSafe  = toBase64Url(standard);

console.log(standard);  // "c29tZSBiaW5hcnkAAGRhdGE="
console.log(urlSafe);   // "c29tZSBiaW5hcnkAAGRhdGE"  (safe for URLs)

I Python, använd base64.urlsafe_b64encode() och base64.urlsafe_b64decode() — de gör substitutionen automatiskt.

Vanliga användningsfall i verkligheten

  • Bädda in bilder i HTML/CSS — en data:-URI som src="data:image/png;base64,iVBORw0KGgo..." eliminerar en separat HTTP-förfrågan. Utmärkt för små ikoner och sprites; inte bra för stora bilder pga 33% storleksökning.
  • JWT-tokens — header- och payload-sektionerna i en JSON Web Token är URL-säkert Base64-kodade JSON-objekt. De tre punktseparerade delarna du ser i en JWT är Base64Url(header).Base64Url(payload).Base64Url(signatur).
  • HTTP Basic-autentisering — headern Authorization: Basic ... kodar användarnamn:lösenord som Base64. Den är definierad i RFC 7617. Obs: det här är kodning, inte kryptering — använd alltid HTTPS.
  • Bädda in binärdata i JSON — JSON har ingen binär typ, så filer, bilder och certifikat som skickas via API Base64-kodas normalt till ett strängfält. Se verktygen File to Base64 och Image to Base64 för detta arbetsflöde.
  • E-postbilagor — MIME (formatet bakom e-post) använder Base64 för att koda binära bilagor så att de överlever transmission genom textrena e-postrelä-servrar. Det ursprungliga problem Base64 designades för att lösa.
  • Lagra binärdata i databaser — när du behöver lagra en liten blob (ett certifikat, en miniatyrbild) i en textkolumn eller inuti ett JSON-dokument, är Base64 standardvalet.

Base64 är INTE kryptering

Det här snubblar folk hela tiden — särskilt vid kodgranskning. Base64 är kodning, inte kryptering. Kodning är en reversibel transformation som ändrar representationen av data. Kryptering förvrider data med en hemlig nyckel så att bara någon med nyckeln kan vända processen.

Vem som helst kan avkoda en Base64-sträng på sekunder — klistra in den i Base64 Decoder och du är klar. Använd aldrig Base64 för att "dölja" känsliga värden som lösenord, API-nycklar eller personuppgifter. Om du behöver konfidentialitet, använd faktisk kryptering (AES, RSA, eller ett bibliotek som Web Crypto API i webbläsaren, eller cryptography i Python).

Värt att notera: Base64 är inte komprimering. Utdata är alltid större än indata — med ungefär en tredjedel. Om du behöver minska storleken, komprimera först (gzip, Brotli, zstd), koda sedan de komprimerade bytes i Base64 om kanalen kräver text.

Verktyg för att arbeta med Base64

Om du arbetar med Base64 dagligen gör snabba verktyg en verklig skillnad. Använd Base64 Encoder för att koda valfri textsträng, Base64 Decoder för att avkoda och inspektera Base64-värden, File to Base64 för att konvertera binärfiler för API-nyttolaster eller lagring, och Image to Base64 för att generera data-URI:er för att bädda in bilder direkt i HTML eller CSS.

Sammanfattning

Base64 finns för att lösa ett specifikt problem: få binärdata genom textrena kanaler utan korruption. Det gör detta genom att mappa varje 3 bytes indata till 4 utskrivbara ASCII-tecken, med ett alfabet på 64 tecken (A–Z, a–z, 0–9, +, /). Resultatet är säkert för e-post, HTTP-headers, JSON-fält och URL:er (med URL-säker variant). Kompromissen är en fast 33% storleksökning. Det är inte kryptering, det är inte komprimering — det är en transparent, reversibel kodning. När du en gång har internaliserat det vet du omedelbart när du ska använda det och när ett annat verktyg passar bättre.

← All Base64 articles Browse all categories →