Du har sandsynligvis set Base64-strenge spredt ud over din kodebase — i JWT-tokens, HTML-tags som <img>, HTTP Authorization-headere eller JSON-payloads der bærer fildata. De ser ud som vrøvl: SGVsbG8sIFdvcmxkIQ==. Men der er en ligetil grund til at de eksisterer, og når du forstår den, holder Base64 op med at være mystisk og begynder at være et genuint nyttigt værktøj i din værktøjskasse.

Hvad Base64 faktisk er

Base64 er et binær-til-tekst kodningsskema. Det er hele sagen. Det tager arbitrær binær data — bytes der kan indeholde null-tegn, kontrolkoder eller enhver værdi fra 0 til 255 — og repræsenterer dem ved brug af kun 64 udskrivbare ASCII-tegn. Resultatet er en streng der sikkert kan rejse gennem enhver tekstbaseret kanal uden at blive beskadiget eller fejlfortolket.

Den formelle specifikation findes i RFC 4648, publiceret af IETF. Den definerer både standard Base64 og URL-sikker variant. Værd at bogmærke hvis du nogensinde skal afgøre en diskussion om udfyldningsregler eller alfabetvalg.

Base64-alfabetet

Det 64-tegns alfabet består af: store bogstaver A–Z (26 tegn), små bogstaver a–z (26 tegn), cifre 0–9 (10 tegn), og to symboler: + og /. Det giver dig præcis 64 tegn — deraf navnet. Tegnet = bruges som udfyldningstegn i slutningen når indtalslængden ikke er et multiplum af 3.

text
ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/

Hvert tegn koder præcis 6 bit data (2^6 = 64 mulige værdier). Det er kernemukanismen bag kodningen — og grunden til den ~33% størrelsesstigning.

Hvordan kodningen fungerer

Algoritmen arbejder i bidder af 3 bytes → 4 Base64-tegn. Tre bytes = 24 bit. Del disse 24 bit op i fire 6-bit grupper, og hver gruppe mapper til ét tegn 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 inddata ikke er deleligt med 3, aktiveres udfyldning. To tilbageværende bytes bliver tre Base64-tegn plus ét =. Én tilbageværende byte bliver to Base64-tegn plus ==. Udfyldningen fortæller blot dekoderen hvor mange bytes der faktisk er til stede i slutningen — det er ikke en del af selve dataene.

Størrelsesstigning: hvert 3 bytes inddata bliver 4 tegns uddata. Det er en 33% størrelsesstigning. For små strenge er det ubetydelig. For store binære filer — et 10 MB billede bliver ca. 13,3 MB Base64 — betyder stigningen noget, og du bør tænke dig om to gange inden du indlejrer direkte.

Kodning og dekodning i JavaScript

Browsere eksponerer btoa() og atob() som globale variabler. De er enkle men har en faldgrube: de håndterer kun Latin-1 tegn (byte-værdier 0–255). Send en multi-byte Unicode-streng direkte og du får 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 — Brug af Buffer

I Node.js er den idiomatiske tilgang Buffer API, som håndterer Unicode korrekt fra start og er meget renere end browserens løsning ovenfor.

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 inkluderer et base64-modul der håndterer kodning, dekodning og URL-sikker variant. Funktionerne arbejder med bytes-objekter, så du typisk koder/dekoder strenge med et eksplicit tegnsæt.

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-sikker Base64

Standard Base64 bruger + og /, som er specialtegn i URL'er. Læg en standard Base64-streng i en forespørgselsparameter og du får subtil beskadigelse medmindre du procent-koder den først. URL-sikker Base64 (også defineret i RFC 4648 §5) løser dette ved at erstatte + med - og / med _. Udfyldningstegn = udelades ofte helt i URL-kontekster.

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, brug base64.urlsafe_b64encode() og base64.urlsafe_b64decode() — de udfører substitutionen automatisk.

Almindelige brugstilfælde i den virkelige verden

  • Indlejring af billeder i HTML/CSS — en data: URI som src="data:image/png;base64,iVBORw0KGgo..." eliminerer en separat HTTP-anmodning. Fremragende til små ikoner og sprites; ikke godt til store billeder pga. 33% størrelsesstigning.
  • JWT-tokens — header- og payload-sektionerne i et JSON Web Token er URL-sikkert Base64-kodede JSON-objekter. De tre punktadskilte dele du ser i en JWT er Base64Url(header).Base64Url(payload).Base64Url(signatur).
  • HTTP Basic-autentificering — headeren Authorization: Basic ... koder brugernavn:adgangskode som Base64. Den er defineret i RFC 7617. Bemærk: dette er kodning, ikke kryptering — brug altid HTTPS.
  • Indlejring af binær data i JSON — JSON har ingen binær type, så filer, billeder og certifikater sendt via API Base64-kodes typisk til et strengfelt. Se værktøjerne File to Base64 og Image to Base64 for dette arbejdsflow.
  • E-mail-vedhæftninger — MIME (formatet bag e-mail) bruger Base64 til at kode binære vedhæftninger så de overlever transmission gennem tekstbaserede mailrelay-servere. Det originale problem Base64 var designet til at løse.
  • Lagring af binær data i databaser — når du skal gemme en lille blob (et certifikat, en miniaturebillede) i en tekstkolonne eller inde i et JSON-dokument, er Base64 standardvalget.

Base64 er IKKE kryptering

Dette snubler folk hele tiden — særligt ved kodegennemgang. Base64 er kodning, ikke kryptering. Kodning er en reversibel transformation der ændrer repræsentationen af data. Kryptering skramler data ved hjælp af en hemmelig nøgle så kun nogen med nøglen kan vende det.

Enhver kan dekode en Base64-streng på sekunder — indsæt den i Base64 Decoder og du er færdig. Brug aldrig Base64 til at "skjule" følsomme værdier som adgangskoder, API-nøgler eller personoplysninger. Hvis du har brug for fortrolighed, brug ægte kryptering (AES, RSA, eller et bibliotek som Web Crypto API i browseren, eller cryptography i Python).

Værd at bemærke: Base64 er ikke komprimering. Outputtet er altid større end inputtet — med ca. en tredjedel. Hvis du skal reducere størrelsen, komprimer først (gzip, Brotli, zstd), Base64-kod derefter de komprimerede bytes hvis kanalen kræver tekst.

Værktøjer til at arbejde med Base64

Hvis du arbejder med Base64 dagligt, gør hurtige værktøjer en reel forskel. Brug Base64 Encoder til at kode enhver tekststreng, Base64 Decoder til at dekode og inspicere Base64-værdier, File to Base64 til at konvertere binære filer til API-payloads eller opbevaring, og Image to Base64 til at generere data-URI'er til indlejring af billeder direkte i HTML eller CSS.

Opsummering

Base64 eksisterer for at løse ét specifikt problem: at få binær data gennem tekstbaserede kanaler uden beskadigelse. Det gør dette ved at mappe hvert 3 bytes inddata til 4 udskrivbare ASCII-tegn, ved hjælp af et alfabet på 64 tegn (A–Z, a–z, 0–9, +, /). Resultatet er sikkert til e-mail, HTTP-headere, JSON-felter og URL'er (med URL-sikker variant). Afvejningen er en fast 33% størrelsesstigning. Det er ikke kryptering, det er ikke komprimering — det er en gennemsigtig, reversibel kodning. Når du en gang har internaliseret det, ved du straks hvornår du skal bruge det og hvornår et andet værktøj passer bedre.

← All Base64 articles Browse all categories →