Base64 decoderen in Go — encoding/base64 + Voorbeelden

Base64-decodering in Go kom je voortdurend tegen — JWT-inspectie, binaire bestandsbijlagen, API-payloads van clouddiensten. Go's standaard encoding/base64-pakket verwerkt dit allemaal, maar het kiezen van de verkeerde coderingvariant (standaard vs. URL-veilig, met of zonder opvulling) is verreweg de meest voorkomende oorzaak van “illegal base64 data”-fouten. Deze gids behandelt StdEncoding, URLEncoding, RawURLEncoding, streaming-decodering met base64.NewDecoder, JWT-payload-inspectie en vier fouten die bijna iedereen de eerste keer maakt. Voor eenmalige decodering in de browser doet ToolDeck's Base64 Decoder het werk direct zonder ook maar één regel code te schrijven.

✓encoding/base64 maakt deel uit van de Go-standaardbibliotheek — geen go get vereist
✓Gebruik RawURLEncoding voor JWT-tokens en de meeste moderne API's (geen opvulling, URL-veilig alfabet)
✓StdEncoding gebruikt + en / met = als opvulling; URLEncoding vervangt deze door - en _ maar behoudt opvulling
✓base64.NewDecoder omhult elke io.Reader voor streaming-decodering zonder alles in het geheugen te laden
✓Controleer altijd de teruggegeven fout — ongeldige opvulling en verkeerd alfabet produceren illegal base64 data

Wat is Base64-decodering?

Base64-codering stelt binaire data voor als ASCII-tekst met 64 afdrukbare tekens (A–Z, a–z, 0–9, plus twee extra). Decoderen keert dit om — het converteert die ASCII-representatie terug naar de oorspronkelijke bytes. Elke 4 Base64-tekens decoderen naar precies 3 bytes. Het schema bestaat omdat veel transportlagen (e-mail, HTTP-headers, JSON-velden) zijn ontworpen voor tekst, niet voor onbewerkte binaire data. Hieronder zie je hoe de volledige cyclus eruitziet:

Go 1.21+

package main

import (
	"encoding/base64"
	"fmt"
)

func main() {
	// Ruwe bytes → Base64-gecodeerd → terug gedecodeerd naar ruwe bytes
	original := []byte("service_token:xK9mP2qR")
	// Gecodeerd: "c2VydmljZV90b2tlbjp4SzltUDJxUg=="

	encoded := base64.StdEncoding.EncodeToString(original)
	decoded, _ := base64.StdEncoding.DecodeString(encoded)
	fmt.Println(string(decoded) == string(original)) // true
}

Base64 decoderen in Go met encoding/base64

Het encoding/base64-pakket wordt meegeleverd met Go — geen externe afhankelijkheden. Het biedt vier vooraf gedefinieerde coderingvarianten als variabelen op pakketniveau. De meest gebruikte functie voor stringinvoer is DecodeString, die een byte-slice en een fout teruggeeft.

Go 1.21+

package main

import (
	"encoding/base64"
	"fmt"
	"log"
)

func main() {
	// Standaard Base64 — het alfabet gebruikt + en / met = als opvulling
	encoded := "eyJob3N0IjoiZGItcHJvZC51cy1lYXN0LTEiLCJwb3J0Ijo1NDMyfQ=="
	decoded, err := base64.StdEncoding.DecodeString(encoded)
	if err != nil {
		log.Fatalf("decode error: %v", err)
	}
	fmt.Println(string(decoded))
	// {"host":"db-prod.us-east-1","port":5432}
}

De methode Decode werkt op byte-slices in plaats van strings en schrijft het resultaat in een vooraf toegewezen doelbuffer. Je moet de buffer correct dimensioneren — gebruik base64.StdEncoding.DecodedLen(len(src)) om de maximale grootte te bepalen (dit kan een paar bytes groter zijn dan de werkelijke gedecodeerde lengte vanwege opvulling).

Go 1.21+

package main

import (
	"encoding/base64"
	"fmt"
	"log"
)

func main() {
	src := []byte("eyJob3N0IjoiZGItcHJvZCIsInBvcnQiOjU0MzJ9")
	dst := make([]byte, base64.RawStdEncoding.DecodedLen(len(src)))

	n, err := base64.RawStdEncoding.Decode(dst, src)
	if err != nil {
		log.Fatalf("decode: %v", err)
	}
	fmt.Println(string(dst[:n]))
	// {"host":"db-prod","port":5432}
}

Opmerking:DecodedLen geeft een bovengrens terug, niet de exacte lengte. Gebruik altijd de retourwaarde n van Decode om het resultaat correct te slicen: dst[:n].

StdEncoding vs URLEncoding — De juiste variant kiezen

Hier zit de meeste verwarring. Go's encoding/base64 biedt vier coderingobjecten, en de verkeerde kiezen geeft gegarandeerd een fout. Het verschil draait om twee dingen: het alfabet en de opvulling.

Go 1.21+

package main

import (
	"encoding/base64"
	"fmt"
)

func main() {
	// JWT-header-payload — URL-veilig, geen opvulling
	jwtHeader := "eyJhbGciOiJSUzI1NiIsImtpZCI6IjIwMjMtMDkifQ"

	// Fout: StdEncoding mislukt bij URL-veilige invoer zonder opvulling
	_, err1 := base64.StdEncoding.DecodeString(jwtHeader)
	fmt.Println("StdEncoding error:", err1)
	// StdEncoding error: illegal base64 data at input byte 43

	// Correct: RawURLEncoding — geen opvulling, URL-veilig alfabet
	decoded, err2 := base64.RawURLEncoding.DecodeString(jwtHeader)
	fmt.Println("RawURLEncoding ok:", err2, "→", string(decoded))
	// RawURLEncoding ok: <nil> → {"alg":"RS256","kid":"2023-09"}
}

De vier varianten in gewone taal:

Functie / Methode

Codering

Opvulling vereist

Geeft terug

base64.StdEncoding.DecodeString(s)

Standaard (+, /)

Ja (=)

([]byte, error)

base64.URLEncoding.DecodeString(s)

URL-veilig (-, _)

Ja (=)

([]byte, error)

base64.RawStdEncoding.DecodeString(s)

Standaard (+, /)

Nee

([]byte, error)

base64.RawURLEncoding.DecodeString(s)

URL-veilig (-, _)

Nee

([]byte, error)

base64.StdEncoding.Decode(dst, src)

Standaard (+, /)

Ja (=)

(n int, error)

base64.NewDecoder(enc, r)

Elke codering

io.Reader

Mijn vuistregel: als het afkomstig is van een JWT, OAuth-flow of een cloud-provider SDK, pak dan eerst RawURLEncoding. Als het van e-mailbijlagen of ouderwetse webformulieren komt, probeer dan StdEncoding. De foutmelding vertelt je altijd de exacte bytepositie waar het decoderen is mislukt.

Base64 decoderen vanuit een bestand en API-respons

Een Base64-gecodeerd bestand lezen

Binaire bestanden (afbeeldingen, PDF's, certificaten) worden soms Base64-gecodeerd op schijf opgeslagen. Lees het bestand in, verwijder eventuele witruimte aan het einde en decodeer:

Go 1.21+

package main

import (
	"encoding/base64"
	"fmt"
	"log"
	"os"
	"strings"
)

func main() {
	raw, err := os.ReadFile("certificate.pem.b64")
	if err != nil {
		log.Fatalf("read file: %v", err)
	}

	// Verwijder regeleinden — Base64-bestanden hebben vaak regelafbrekingen om de 76 tekens
	cleaned := strings.ReplaceAll(strings.TrimSpace(string(raw)), "\n", "")

	decoded, err := base64.StdEncoding.DecodeString(cleaned)
	if err != nil {
		log.Fatalf("decode: %v", err)
	}

	if err := os.WriteFile("certificate.pem", decoded, 0600); err != nil {
		log.Fatalf("write: %v", err)
	}
	fmt.Printf("decoded %d bytes → certificate.pem\n", len(decoded))
}

Een Base64-veld decoderen uit een API JSON-respons

Cloud-API's retourneren binaire data (versleutelingssleutels, ondertekende blobs, miniaturen) vaak als Base64-strings binnen JSON. Unmarshall eerst de JSON en decodeer daarna het doelveld:

Go 1.21+

package main

import (
	"encoding/base64"
	"encoding/json"
	"fmt"
	"log"
	"net/http"
)

type SecretResponse struct {
	Name    string `json:"name"`
	Payload string `json:"payload"` // Base64-gecodeerde geheime waarde
	Version int    `json:"version"`
}

func fetchAndDecodeSecret(secretURL string) ([]byte, error) {
	resp, err := http.Get(secretURL)
	if err != nil {
		return nil, fmt.Errorf("http get: %w", err)
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		return nil, fmt.Errorf("unexpected status: %d", resp.StatusCode)
	}

	var secret SecretResponse
	if err := json.NewDecoder(resp.Body).Decode(&secret); err != nil {
		return nil, fmt.Errorf("decode json: %w", err)
	}

	value, err := base64.StdEncoding.DecodeString(secret.Payload)
	if err != nil {
		return nil, fmt.Errorf("decode base64: %w", err)
	}
	return value, nil
}

func main() {
	value, err := fetchAndDecodeSecret("https://api.example.com/secrets/db-password")
	if err != nil {
		log.Fatalf("fetch secret: %v", err)
	}
	fmt.Printf("secret value: %s\n", value)
}

Opmerking:Omhul fouten met fmt.Errorf("decode base64: %w", err) in plaats van context te verliezen. De originele foutmelding van encoding/base64 bevat de bytepositie van de fout, wat nuttig is tijdens het debuggen.

Grote Base64-gecodeerde bestanden streamen

Een Base64-gecodeerd bestand van 500 MB in het geheugen laden met os.ReadFile en daarna DecodeString aanroepen kost ongeveer 750 MB RAM (de gecodeerde string plus de gedecodeerde bytes). base64.NewDecoder omhult elke io.Reader en decodeert in stukken, waardoor het geheugengebruik nagenoeg constant blijft. Combineer het met io.Copy voor een nette streaming-pipeline:

Go 1.21+

package main

import (
	"encoding/base64"
	"fmt"
	"io"
	"log"
	"os"
)

func streamDecodeFile(srcPath, dstPath string) error {
	src, err := os.Open(srcPath)
	if err != nil {
		return fmt.Errorf("open source: %w", err)
	}
	defer src.Close()

	dst, err := os.Create(dstPath)
	if err != nil {
		return fmt.Errorf("create dest: %w", err)
	}
	defer dst.Close()

	decoder := base64.NewDecoder(base64.StdEncoding, src)
	written, err := io.Copy(dst, decoder)
	if err != nil {
		return fmt.Errorf("stream decode: %w", err)
	}
	fmt.Printf("written %d bytes to %s\n", written, dstPath)
	return nil
}

func main() {
	if err := streamDecodeFile("backup.tar.b64", "backup.tar"); err != nil {
		log.Fatal(err)
	}
}

Waarschuwing:base64.NewDecoder verwacht schone, ononderbroken Base64-data. Als het bronbestand regelafbrekingen bevat (gebruikelijk in PEM- en MIME-gecodeerde bestanden), omhul de bronreader dan met een reader die regels verwijdert, of verwerk het bestand vooraf om regeleinden te verwijderen voor het streamen.

Base64-decodering via de opdrachtregel

De meeste Go-ontwikkelaars grijpen als eerste naar de opdrachtregel bij het debuggen. Elk macOS- en Linux-systeem wordt geleverd met base64; op Windows heeft PowerShell een ingebouwd equivalent. Voor snelle inspectie van API-payloads gaat dit sneller dan een Go-script schrijven.

bash

# Decodeer een Base64-string (Linux / macOS)
echo "eyJob3N0IjoiZGItcHJvZCIsInBvcnQiOjU0MzJ9" | base64 --decode
# {"host":"db-prod","port":5432}

# Decodeer en geef mooi weer met jq (leid de JSON-uitvoer door)
echo "eyJob3N0IjoiZGItcHJvZCIsInBvcnQiOjU0MzJ9" | base64 --decode | jq .
# {
#   "host": "db-prod",
#   "port": 5432
# }

# Decodeer een Base64-gecodeerd bestand naar binair
base64 --decode < encrypted_payload.b64 > encrypted_payload.bin

# macOS gebruikt de vlag -D in plaats van --decode
echo "c2VjcmV0LXRva2Vu" | base64 -D

Voor het inspecteren van JWT-tokens zonder geïnstalleerde tools, plak het token in ToolDeck's Base64 Decoder — splits op de punten en decodeer elk onderdeel.

Hoge-prestatiealternatief: encoding/base64 is al snel

Anders dan bij Python, waar orjson vs. jsoneen zinvol prestatiegesprek is, is Go's encoding/base64 al assembly-geoptimaliseerd en voor de meeste workloads daadwerkelijk snel. Dat gezegd hebbende: als je miljoenen records verwerkt in een strakke loop, biedt filippo.io/base64 SIMD-versnelde decodering met een drop-in API.

bash

go get filippo.io/base64

Go 1.21+

package main

import (
	"fmt"
	"log"

	"filippo.io/base64"
)

func main() {
	// Drop-in vervanging — dezelfde API als encoding/base64
	encoded := "eyJob3N0IjoiY2FjaGUtcHJvZCIsInBvcnQiOjYzNzl9"
	decoded, err := base64.StdEncoding.DecodeString(encoded)
	if err != nil {
		log.Fatalf("decode: %v", err)
	}
	fmt.Println(string(decoded))
	// {"host":"cache-prod","port":6379}
}

De prestatieverbetering is het meest zichtbaar op amd64 met AVX2-ondersteuning — benchmarks tonen een 2–4x hogere doorvoer bij grote invoer. Voor alledaagse API-respons-decodering (een paar honderd bytes per keer) blijf je beter bij de standaardbibliotheek.

Base64 JWT-payload decoderen in Go

JWT-inspectie komt voor in vrijwel elke backendservice. In mijn ervaring draait de meeste debugsessies uiteindelijk op “wat zit er eigenlijk in dit token?” — en dat kun je beantwoorden zonder een volledige JWT-bibliotheek te laden. Het token heeft drie Base64url-gecodeerde segmenten gescheiden door punten. Het middelste segment is de payload die je daadwerkelijk nodig hebt:

Go 1.21+

package main

import (
	"encoding/base64"
	"encoding/json"
	"fmt"
	"log"
	"strings"
)

type JWTPayload struct {
	Subject  string   `json:"sub"`
	Issuer   string   `json:"iss"`
	Expiry   int64    `json:"exp"`
	Roles    []string `json:"roles"`
}

func decodeJWTPayload(token string) (*JWTPayload, error) {
	parts := strings.Split(token, ".")
	if len(parts) != 3 {
		return nil, fmt.Errorf("invalid JWT: expected 3 segments, got %d", len(parts))
	}

	// JWT gebruikt RawURLEncoding — URL-veilig alfabet, geen = als opvulling
	raw, err := base64.RawURLEncoding.DecodeString(parts[1])
	if err != nil {
		return nil, fmt.Errorf("decode payload: %w", err)
	}

	var payload JWTPayload
	if err := json.Unmarshal(raw, &payload); err != nil {
		return nil, fmt.Errorf("unmarshal payload: %w", err)
	}
	return &payload, nil
}

func main() {
	token := "eyJhbGciOiJSUzI1NiJ9.eyJzdWIiOiJ1c3ItNDQyIiwiaXNzIjoiYXV0aC5leGFtcGxlLmNvbSIsImV4cCI6MTc0MTk1NjgwMCwicm9sZXMiOlsiYWRtaW4iLCJhdWRpdG9yIl19.SIGNATURE"

	payload, err := decodeJWTPayload(token)
	if err != nil {
		log.Fatalf("jwt: %v", err)
	}
	fmt.Printf("Subject: %s\n", payload.Subject)
	fmt.Printf("Issuer:  %s\n", payload.Issuer)
	fmt.Printf("Roles:   %v\n", payload.Roles)
	// Subject: usr-442
	// Issuer:  auth.example.com
	// Roles:   [admin auditor]
}

Veelgemaakte fouten

Ik ben alle vier in echte code-reviews tegengekomen — de eerste twee in het bijzonder duiken bijna altijd op wanneer iemand een nieuwe auth-provider integreert.

❌ StdEncoding gebruiken op URL-veilige invoer

Probleem: JWT-tokens en OAuth-tokens gebruiken het URL-veilige Base64-alfabet (- en _). Ze doorgeven aan StdEncoding.DecodeString mislukt met 'illegal base64 data'.

Oplossing: Controleer de invoerbron: tokens van auth-systemen gebruiken RawURLEncoding; binaire bijlagen gebruiken StdEncoding.

Before · Go

After · Go

// JWT-header — URL-veilig, geen opvulling
token := "eyJhbGciOiJSUzI1NiJ9"
decoded, err := base64.StdEncoding.DecodeString(token)
// err: illegal base64 data at input byte 19

// JWT-header — juiste codering
token := "eyJhbGciOiJSUzI1NiJ9"
decoded, err := base64.RawURLEncoding.DecodeString(token)
// decoded: {"alg":"RS256"}
// err: nil

❌ De retourwaarde n van Decode negeren

Probleem: Decode schrijft naar een vooraf toegewezen buffer en geeft het aantal werkelijk geschreven bytes terug. DecodedLen geeft een bovengrens, dus de staart van de buffer kan rommelwaarden bevatten.

Oplossing: Slice het resultaat altijd met dst[:n] — niet met dst[:len(dst)].

Before · Go

After · Go

dst := make([]byte, base64.StdEncoding.DecodedLen(len(src)))
base64.StdEncoding.Decode(dst, src)
fmt.Println(string(dst)) // kan afsluitende nulbytes bevatten

dst := make([]byte, base64.StdEncoding.DecodedLen(len(src)))
n, err := base64.StdEncoding.Decode(dst, src)
if err != nil {
    log.Fatal(err)
}
fmt.Println(string(dst[:n])) // correct — alleen de gedecodeerde bytes

❌ Witruimte niet verwijderen voor het decoderen

Probleem: Base64-strings gekopieerd uit terminals, e-mails of configuratiebestanden hebben vaak afsluitende regeleinden of spaties. Ze direct doorgeven aan DecodeString mislukt bij het witruimteteken.

Oplossing: Roep strings.TrimSpace aan (en strings.ReplaceAll voor ingebedde regeleinden) voor het decoderen.

Before · Go

After · Go

// Waarde gelezen uit een configuratiebestand met een afsluitend regeleinde
encoded := "c2VydmljZV9rZXk6eEtNcDI=\n"
decoded, err := base64.StdEncoding.DecodeString(encoded)
// err: illegal base64 data at input byte 24

encoded := "c2VydmljZV9rZXk6eEtNcDI=\n"
cleaned := strings.TrimSpace(encoded)
decoded, err := base64.StdEncoding.DecodeString(cleaned)
// decoded: "service_key:xKMp2"
// err: nil

❌ Gedecodeerde bytes onjuist als string opslaan

Probleem: string(decoded) aanroepen op binaire data (afbeeldingen, gecomprimeerde payloads) levert ongeldige UTF-8-strings op. Go-strings kunnen willekeurige bytes bevatten, maar sommige operaties zullen de inhoud beschadigen.

Oplossing: Houd binaire data als []byte door je gehele pipeline. Roep string(decoded) alleen aan als de gedecodeerde inhoud gegarandeerd tekst is.

Before · Go

After · Go

decoded, _ := base64.StdEncoding.DecodeString(pngBase64)
// Binaire PNG als string behandelen verliest data
imageStr := string(decoded)
os.WriteFile("image.png", []byte(imageStr), 0644) // kan beschadigen

decoded, err := base64.StdEncoding.DecodeString(pngBase64)
if err != nil {
    log.Fatal(err)
}
// Schrijf bytes direct — geen stringconversie
os.WriteFile("image.png", decoded, 0644)

Methodevergelijking

Alle varianten worden meegeleverd in de standaardbibliotheek — geen externe afhankelijkheden voor geen van deze methoden.

Methode

Invoertype

Coderingsvarianten

Streaming

Aangepast alfabet

Aangepaste opvulling

Installatie vereist

StdEncoding.DecodeString

string

Standaard

✗

Nee (stdlib)

URLEncoding.DecodeString

string

URL-veilig

✗

Nee (stdlib)

RawStdEncoding.DecodeString

string

Standaard (geen opvulling)

✗

Nee (stdlib)

RawURLEncoding.DecodeString

string

URL-veilig (geen opvulling)

✗

Nee (stdlib)

StdEncoding.Decode

[]byte

Standaard

✗

Nee (stdlib)

base64.NewDecoder

io.Reader

Alle

✓

✗

Nee (stdlib)

encoding/base64 + NewEncoding

string

Aangepast alfabet

✗

✓

Nee (stdlib)

Voor JWT-tokens en OAuth-flows: RawURLEncoding. Voor e-mailbijlagen en MIME-data: StdEncoding. Voor grote binaire bestanden van schijf of netwerk: omhul een reader in base64.NewDecoder — het geheugengebruik blijft constant ongeacht de bestandsgrootte. Aangepast alfabet nodig? base64.NewEncoding(alphabet) bouwt een nieuw coderingobject voor bijzondere gevallen.

Voor snelle eenmalige controles tijdens de ontwikkeling is de online Base64 Decoder sneller dan een Go-programma opstarten.

Veelgestelde vragen

Hoe decodeer ik een Base64-string in Go?

Importeer encoding/base64 en roep base64.StdEncoding.DecodeString(s) aan. Dit geeft ([]byte, error) terug — controleer de fout altijd. Als de string URL-veilige tekens bevat (- en _ in plaats van + en /), gebruik dan base64.URLEncoding.DecodeString. Voor JWT-tokens en de meeste moderne API's is RawURLEncoding (geen opvulling) de juiste keuze.

Go 1.21+

package main

import (
	"encoding/base64"
	"fmt"
	"log"
)

func main() {
	encoded := "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9"
	decoded, err := base64.RawURLEncoding.DecodeString(encoded)
	if err != nil {
		log.Fatalf("decode: %v", err)
	}
	fmt.Println(string(decoded))
	// {"alg":"HS256","typ":"JWT"}
}

Wat is het verschil tussen StdEncoding en URLEncoding in Go?

StdEncoding gebruikt het standaard Base64-alfabet met de tekens + en / en = als opvulling — gedefinieerd in RFC 4648 §4. URLEncoding vervangt + door - en / door _, waardoor de uitvoer veilig is in URL's en HTTP-headers zonder percent-codering — gedefinieerd in RFC 4648 §5. Gebruik URLEncoding voor JWT-tokens, OAuth-tokens en alle data ingebed in querystrings.

Go 1.21+

package main

import (
	"encoding/base64"
	"fmt"
)

func main() {
	// Standaard: kan + / en = bevatten
	std := base64.StdEncoding.EncodeToString([]byte("hello/world"))
	fmt.Println(std) // "aGVsbG8vd29ybGQ="

	// URL-veilig: vervangt + door - en / door _
	url := base64.URLEncoding.EncodeToString([]byte("hello/world"))
	fmt.Println(url) // "aGVsbG8vd29ybGQ=" (zelfde — verschil bij andere bytes)

	// JWT-headers hebben nooit opvulling — gebruik RawURLEncoding
	raw := base64.RawURLEncoding.EncodeToString([]byte("hello/world"))
	fmt.Println(raw) // "aGVsbG8vd29ybGQ" (geen afsluitende =)
}

Hoe los ik "illegal base64 data"-fouten in Go op?

Deze fout betekent dat de invoer tekens bevat buiten het verwachte alfabet, of dat de opvulling onjuist is. Drie veelvoorkomende oorzaken: StdEncoding gebruiken op URL-veilige invoer (vervang door URLEncoding), een gevulde encoder gebruiken op invoer zonder opvulling (vervang door RawStdEncoding/RawURLEncoding), of spaties/regeleinden aan het einde. Verwijder witruimte met strings.TrimSpace vóór het decoderen.

Go 1.21+

package main

import (
	"encoding/base64"
	"fmt"
	"log"
	"strings"
)

func main() {
	// Invoer van een webhook-payload — heeft regeleinden uit het wire-formaat verwijderd
	raw := "  aGVsbG8gd29ybGQ=  \n"
	cleaned := strings.TrimSpace(raw)

	decoded, err := base64.StdEncoding.DecodeString(cleaned)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(string(decoded)) // hello world
}

Hoe kan ik een groot Base64-gecodeerd bestand streamen in Go?

Gebruik base64.NewDecoder(base64.StdEncoding, reader), dat elke io.Reader omhult en tijdens het lezen decodeert. Leid het door io.Copy om naar de bestemming te schrijven zonder het hele bestand in het geheugen te bufferen. Dit is het standaardpatroon voor het decoderen van Base64-gecodeerde binaire bijlagen of grote datapayloads.

Go 1.21+

package main

import (
	"encoding/base64"
	"io"
	"log"
	"os"
)

func main() {
	src, err := os.Open("attachment.b64")
	if err != nil {
		log.Fatal(err)
	}
	defer src.Close()

	dst, err := os.Create("attachment.bin")
	if err != nil {
		log.Fatal(err)
	}
	defer dst.Close()

	decoder := base64.NewDecoder(base64.StdEncoding, src)
	io.Copy(dst, decoder)
}

Kan ik een Base64 JWT-payload in Go decoderen zonder een JWT-bibliotheek?

Ja. Een JWT bestaat uit drie Base64url-gecodeerde segmenten gescheiden door punten. Splits op "." en decodeer het tweede segment (index 1) met base64.RawURLEncoding.DecodeString — JWT-headers en -payloads gebruiken het URL-veilige alfabet zonder opvulling. Het handtekeningsegment (index 2) is binair en wordt doorgaans alleen gebruikt voor verificatie.

Go 1.21+

package main

import (
	"encoding/base64"
	"fmt"
	"log"
	"strings"
)

func main() {
	token := "eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJ1c3ItOTAxIiwicm9sZSI6ImFkbWluIn0.SIG"
	parts := strings.Split(token, ".")
	if len(parts) < 2 {
		log.Fatal("invalid JWT format")
	}

	payload, err := base64.RawURLEncoding.DecodeString(parts[1])
	if err != nil {
		log.Fatalf("decode payload: %v", err)
	}
	fmt.Println(string(payload))
	// {"sub":"usr-901","role":"admin"}
}

Welke codering gebruik ik om Base64-data uit een HTTP API-respons te decoderen?

Raadpleeg de API-documentatie of inspecteer de gecodeerde string. Als deze + of / bevat en eindigt op =, gebruik dan StdEncoding. Als de string - en _ bevat zonder =, gebruik dan RawURLEncoding. Probeer bij twijfel eerst RawURLEncoding — de meeste moderne API's (OAuth2, JWT, Google Cloud, AWS) gebruiken URL-veilige Base64 zonder opvulling.

Go 1.21+

package main

import (
	"encoding/base64"
	"strings"
)

// Detecteer de coderingvariant op basis van de gecodeerde string
func decodeAPIPayload(encoded string) ([]byte, error) {
	// URL-veilige tekens zonder opvulling — gebruikelijk in moderne API's
	if !strings.Contains(encoded, "+") && !strings.Contains(encoded, "/") {
		return base64.RawURLEncoding.DecodeString(encoded)
	}
	// Standaard Base64 met opvulling
	return base64.StdEncoding.DecodeString(encoded)
}

Gerelateerde tools

Base64 Encoder — codeer binaire data of tekst naar Base64 in de browser; handig voor het genereren van testfixtures die je in je Go-unit-tests plakt.
JWT Decoder — splits en decodeer alle drie JWT-segmenten tegelijk, met veld-voor-veld payload-inspectie — geen Go-code vereist als je alleen een token wilt lezen tijdens het debuggen.
URL Decoder — percent-decodeer URL-gecodeerde strings; handig wanneer API-responsen Base64url-data mengen met percent-gecodeerde queryparameters.
JSON Formatter — plak na het decoderen van een Base64 JWT-payload of API-respons de JSON hier om de structuur direct mooi weer te geven en te valideren.