Decode Base64 Python — Panduan base64.b64decode()

Saat API mengembalikan field content yang terlihat seperti eyJob3N0IjogImRiLXByb2Qi…, atau secrets manager memberikan kredensial yang sudah dikodekan, atau Anda perlu mengekstrak payload JWT—— dekode base64 Python adalah langkah pertama Anda. Modul base64 bawaan menangani semuanya, namun detail kecil seputar bytes vs string, alfabet yang aman untuk URL, dan padding yang hilang selalu menjebak hampir setiap developer setidaknya sekali—— saya sudah men-debug kategori error ini di code review lebih banyak dari yang ingin saya akui. Panduan ini mencakup base64.b64decode(), urlsafe_b64decode(), perbaikan padding otomatis, dekode dari file dan respons HTTP, alat CLI, validasi input, dan empat kesalahan umum dengan perbaikan sebelum/sesudah——semua contoh Python 3.8+ yang bisa dijalankan. Jika Anda hanya perlu dekode cepat sekali tanpa menulis kode, Dekoder Base64 ToolDeck menangani Base64 standar dan yang aman untuk URL secara instan di browser Anda.

Apa itu Dekoding Base64?

Base64 adalah skema encoding yang merepresentasikan data biner arbitrer sebagai string dari 64 karakter ASCII yang dapat dicetak: A–Z, a–z, 0–9, +, dan /, dengan = digunakan sebagai padding. Setiap 4 karakter Base64 mengkodekan tepat 3 byte asli, sehingga bentuk yang dikodekan kira-kira 33% lebih besar dari sumbernya. Dekoding membalik prosesnya — mengubah representasi ASCII kembali menjadi byte asli.

Base64 tidak mengenkripsi data. Ini murni encoding biner-ke-teks — string yang dikodekan dapat dibaca sepenuhnya oleh siapa saja yang menjalankannya melalui dekoder:

base64.b64decode() — Dekoding Pustaka Standar

Modul base64 Python disertakan bersama pustaka standar——tidak perlu instalasi, selalu tersedia. Fungsi utamanya adalah base64.b64decode(s, altchars=None, validate=False). Fungsi ini menerima str, bytes, atau bytearray, dan selalu mengembalikan bytes.

Contoh minimal yang berfungsi

import base64
import json

# Encoded database config received from a secrets manager
encoded_config = (
    "eyJob3N0IjogImRiLXByb2QubXljb21wYW55LmludGVybmFsIiwgInBvcnQiOiA1NDMyLCAid"
    "XNlciI6ICJhcHBfc3ZjIiwgInBhc3N3b3JkIjogInM0ZmVQYXNzITIwMjYifQ=="
)

# Step 1: decode Base64 bytes
raw_bytes = base64.b64decode(encoded_config)
print(raw_bytes)
# b'{"host": "db-prod.mycompany.internal", "port": 5432, "user": "app_svc", "password": "s4fePass!2026"}'

# Step 2: convert bytes → str
config_str = raw_bytes.decode("utf-8")

# Step 3: parse into a dict
config = json.loads(config_str)
print(config["host"])    # db-prod.mycompany.internal
print(config["port"])    # 5432

Contoh diperluas: sort_keys, ensure_ascii, dan validasi ketat

import base64
import binascii

# Token from an internal event bus — validate strictly (external input)
encoded_event = (
    "eyJldmVudCI6ICJvcmRlci5zaGlwcGVkIiwgIm9yZGVyX2lkIjogIk9SRC04ODQ3MiIsICJ"
    "0aW1lc3RhbXAiOiAiMjAyNi0wMy0xM1QxNDozMDowMFoiLCAicmVnaW9uIjogImV1LXdlc3QtMSJ9"
)

try:
    # validate=True raises binascii.Error on any non-Base64 character
    raw = base64.b64decode(encoded_event, validate=True)
    event = raw.decode("utf-8")
    print(event)
    # {"event": "order.shipped", "order_id": "ORD-88472", "timestamp": "2026-03-13T14:30:00Z", "region": "eu-west-1"}

except binascii.Error as exc:
    print(f"Invalid Base64: {exc}")
except UnicodeDecodeError as exc:
    print(f"Not UTF-8 text: {exc}")

Mendekode Base64 yang Aman untuk URL (base64url)

Base64 standar menggunakan + dan /, yang merupakan karakter yang dicadangkan dalam URL. Varian yang aman untuk URL (RFC 4648 §5, juga disebut “base64url”) menggantinya dengan - dan _. Ini adalah encoding yang digunakan dalam token JWT, tantangan OAuth 2.0 PKCE, kredensial Google Cloud, dan sebagian besar alur autentikasi web modern.

Memberikan Base64 yang aman untuk URL ke b64decode() tanpa menyesuaikan alfabet akan merusak data secara diam-diam atau memunculkan binascii.Error. Gunakan base64.urlsafe_b64decode() sebagai gantinya — ini menangani penggantian- → + dan _ → / secara otomatis.

import base64
import json

# JWT payload segment (the middle part between the two dots)
# JWTs use URL-safe Base64 without trailing "=" padding
jwt_payload_b64 = (
    "eyJ1c2VyX2lkIjogMjg5MywgInJvbGUiOiAiYWRtaW4iLCAiaXNzIjogImF1dGgubXljb21w"
    "YW55LmNvbSIsICJleHAiOiAxNzQwOTAwMDAwLCAianRpIjogImFiYzEyMzQ1LXh5ei05ODc2In0"
)

# Restore padding before decoding (JWT deliberately omits '=')
padded = jwt_payload_b64 + "=" * (-len(jwt_payload_b64) % 4)

payload_bytes = base64.urlsafe_b64decode(padded)
payload = json.loads(payload_bytes.decode("utf-8"))

print(payload["role"])    # admin
print(payload["iss"])     # auth.mycompany.com
print(payload["user_id"]) # 2893

Referensi Parameter base64.b64decode()

Semua parameter di bawah ini berlaku untuk b64decode() dan urlsafe_b64decode(), kecuali altchars yang hanya tersedia di b64decode().

Default validate=False disengaja untuk data berformat PEM dan Base64 multi-baris (di mana baris baru umum terjadi). Untuk payload API, unggahan pengguna, atau input yang tidak terpercaya, berikan validate=True untuk mendeteksi data yang rusak atau disuntikkan lebih awal dan menampilkan error yang jelas.

Error Padding Dekode Base64 Python — Cara Memperbaikinya

Error yang paling sering muncul saat mendekode Base64 di Python adalah:

import base64

base64.b64decode("eyJ0eXBlIjogImFjY2VzcyJ9")
# binascii.Error: Incorrect padding

Base64 membutuhkan panjang string yang merupakan kelipatan 4. Saat data melewati URL, header HTTP, atau pustaka JWT, padding = di akhir dihapus untuk menghemat byte. Ada dua cara yang dapat diandalkan untuk memperbaikinya.

Opsi 1: Pulihkan padding secara inline (direkomendasikan)

import base64
import json

def b64decode_unpadded(data: str | bytes) -> bytes:
    """Decode Base64 with automatic padding correction."""
    if isinstance(data, str):
        data = data.encode("ascii")
    data += b"=" * (-len(data) % 4)
    return base64.b64decode(data)

# Works regardless of how many '=' were stripped
token_a = "eyJ0eXBlIjogImFjY2VzcyJ9"       # 0 chars of padding stripped
token_b = "eyJ0eXBlIjogInJlZnJlc2gifQ"      # 1 char stripped
token_c = "eyJ0eXBlIjogImFwaV9rZXkifQ=="    # already padded

for token in (token_a, token_b, token_c):
    result = json.loads(b64decode_unpadded(token).decode("utf-8"))
    print(result["type"])
# access
# refresh
# api_key

Opsi 2: Dekode aman untuk URL dengan padding untuk OAuth / JWT

import base64
import json

def decode_jwt_segment(segment: str) -> dict:
    """Decode a single JWT segment (header or payload)."""
    # Add padding, use URL-safe alphabet
    padded = segment + "=" * (-len(segment) % 4)
    raw = base64.urlsafe_b64decode(padded)
    return json.loads(raw.decode("utf-8"))

# Google OAuth ID token payload (simplified)
id_token_payload = (
    "eyJzdWIiOiAiMTEwNTY5NDkxMjM0NTY3ODkwMTIiLCAiZW1haWwiOiAic2FyYS5jaGVuQGV4"
    "YW1wbGUuY29tIiwgImhkIjogImV4YW1wbGUuY29tIiwgImlhdCI6IDE3NDA5MDAwMDB9"
)

claims = decode_jwt_segment(id_token_payload)
print(claims["email"])   # sara.chen@example.com
print(claims["hd"])      # example.com

Mendekode Base64 dari File dan Respons API

Membaca Base64 dari disk dan mendekode payload API adalah dua skenario produksi yang paling umum. Keduanya memerlukan penanganan error yang tepat — padding yang rusak dan tipe biner yang tidak terduga adalah kejadian nyata, bukan kasus tepi yang teoritis.

Membaca dan mendekode file Base64

import base64
import json
from pathlib import Path

def decode_attachment(envelope_path: str, output_path: str) -> None:
    """
    Read a JSON envelope with a Base64-encoded attachment,
    decode it, and write the binary output to disk.
    """
    try:
        envelope = json.loads(Path(envelope_path).read_text(encoding="utf-8"))
        encoded_data = envelope["attachment"]["data"]
        file_bytes = base64.b64decode(encoded_data, validate=True)
        Path(output_path).write_bytes(file_bytes)
        print(f"Saved {len(file_bytes):,} bytes → {output_path}")
    except FileNotFoundError:
        print(f"Envelope file not found: {envelope_path}")
    except (KeyError, TypeError):
        print("Unexpected envelope structure — 'attachment.data' missing")
    except base64.binascii.Error as exc:
        print(f"Invalid Base64 content: {exc}")

# Example envelope:
# {"attachment": {"filename": "invoice_2026_03.pdf", "data": "JVBERi0xLjQK..."}}
decode_attachment("order_ORD-88472.json", "invoice_2026_03.pdf")

Mendekode Base64 dari respons API HTTP

import base64
import json
import urllib.request

def fetch_and_decode_secret(vault_url: str, secret_name: str) -> str:
    """
    Retrieve a Base64-encoded secret from an internal vault API
    and return the decoded plaintext value.
    """
    url = f"{vault_url}/v1/secrets/{secret_name}"
    req = urllib.request.Request(url, headers={"X-Vault-Token": "s.internal"})

    try:
        with urllib.request.urlopen(req, timeout=5) as resp:
            body = json.loads(resp.read().decode("utf-8"))
            # Vault returns: {"data": {"value": "<base64>", "encoding": "base64"}}
            encoded = body["data"]["value"]
            return base64.b64decode(encoded).decode("utf-8")

    except urllib.error.URLError as exc:
        raise RuntimeError(f"Vault unreachable: {exc}") from exc
    except (KeyError, UnicodeDecodeError, base64.binascii.Error) as exc:
        raise ValueError(f"Unexpected secret format: {exc}") from exc

# db_pass = fetch_and_decode_secret("https://vault.internal", "db-prod-password")
# print(db_pass)  # s4feP@ss!2026

Dekoding Base64 Lewat Baris Perintah

Untuk inspeksi terminal cepat — memverifikasi token, mengintip blob konfigurasi yang dikodekan, atau menyalurkan output API melalui dekoder — perintah base64 tersedia di Linux dan macOS. Modul -m base64 bawaan Python bekerja lintas platform termasuk Windows.

# Decode a Base64 string and print the result (Linux / macOS)
echo "eyJob3N0IjogImRiLXByb2QubXljb21wYW55LmludGVybmFsIn0=" | base64 --decode
# {"host": "db-prod.mycompany.internal"}

# Decode a file, save decoded output
base64 --decode encoded_payload.txt > decoded_output.json

# Python's cross-platform CLI decoder (works on Windows too)
python3 -m base64 -d encoded_payload.txt

# Decode a JWT payload segment inline — strip header/signature first
echo "eyJ1c2VyX2lkIjogMjg5MywgInJvbGUiOiAiYWRtaW4ifQ" | python3 -c "
import sys, base64, json
s = sys.stdin.read().strip()
padded = s + '=' * (-len(s) % 4)
print(json.dumps(json.loads(base64.urlsafe_b64decode(padded)), indent=2))
"

Untuk pekerjaan eksplorasi di mana menulis pipeline shell terasa berlebihan, tempelkan string ke Dekoder Base64 online — ia mendeteksi input yang aman untuk URL secara otomatis dan memperbaiki padding di tempat.

Memvalidasi Input Base64 Sebelum Mendekode

Saat data Base64 datang dari input pengguna, webhook, atau API pihak ketiga yang tidak terpercaya, validasilah sebelum mendekode untuk menampilkan error yang bersih dan dapat ditindaklanjuti, bukan traceback binascii.Error yang membingungkan jauh di dalam logika bisnis. Python memberi Anda dua pendekatan: tangkap exception, atau pra-validasi dengan regex.

import base64
import binascii
import re

# ── Option A: try/except (recommended for most code paths) ──────────────────

def safe_b64decode(data: str) -> bytes | None:
    """Return decoded bytes, or None if the input is not valid Base64."""
    try:
        padded = data + "=" * (-len(data) % 4)
        return base64.b64decode(padded, validate=True)
    except (binascii.Error, ValueError):
        return None

print(safe_b64decode("not-base64!!"))                     # None
print(safe_b64decode("eyJ0eXBlIjogInJlZnJlc2gifQ"))      # b'{"type": "refresh"}'


# ── Option B: regex pre-validation ──────────────────────────────────────────

# Standard Base64 (alphabet: A-Z a-z 0-9 + /)
_STANDARD_RE = re.compile(r"^[A-Za-z0-9+/]*={0,2}$")

# URL-safe Base64 (alphabet: A-Z a-z 0-9 - _)
_URLSAFE_RE = re.compile(r"^[A-Za-z0-9-_]*={0,2}$")

def is_valid_base64(s: str) -> bool:
    """True if s is a syntactically valid standard Base64 string."""
    # Length must be a multiple of 4 for fully padded strings
    stripped = s.rstrip("=")
    padded = stripped + "=" * (-len(stripped) % 4)
    return bool(_STANDARD_RE.match(padded))

print(is_valid_base64("SGVsbG8gV29ybGQ="))   # True
print(is_valid_base64("SGVsbG8gV29ybGQ!"))   # False  (! is not Base64)

Alternatif Berkinerja Tinggi: pybase64

Untuk sebagian besar kasus penggunaan, modul base64 stdlib Python sudah sepenuhnya memadai. Jika Anda memproses ribuan payload API per detik, mendekode lampiran biner multi-megabyte dalam loop ketat, atau profiler Anda menunjukkan operasi Base64 sebagai titik panas — pertimbangkan pybase64. Ini adalah wrapper ekstensi C di sekitar libbase64 dan biasanya 2–5× lebih cepat dari implementasi stdlib pada input besar.

pip install pybase64

import pybase64

# Drop-in replacement — identical API to the stdlib base64 module
encoded_image = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAAC0lEQVQI12NgAAIABQ..."

image_bytes = pybase64.b64decode(encoded_image, validate=False)
print(f"Decoded {len(image_bytes):,} bytes")

# URL-safe variant — same as base64.urlsafe_b64decode()
token_bytes = pybase64.urlsafe_b64decode("eyJpZCI6IDQ3MX0=")
print(token_bytes)  # b'{"id": 471}'

# Benchmark note: on strings under ~10 KB the function-call overhead dominates
# and the speedup is negligible. Profile before switching.

API-nya sengaja dibuat identik dengan base64 — ganti impor dan tidak ada yang berubah. Gunakan hanya saat profiling mengonfirmasi bahwa Base64 memang menjadi bottleneck, yang jarang terjadi di luar pipeline data throughput tinggi.

Kesalahan Umum

Saya telah melihat keempat error ini berulang kali dalam code review — mereka sangat umum di antara developer yang berasal dari bahasa seperti JavaScript atau PHP di mana dekode Base64 mengembalikan string secara langsung, atau dari tutorial yang melewatkan penanganan error sepenuhnya.

Kesalahan 1: Lupa memanggil .decode() pada hasilnya

# ❌ b64decode() returns bytes — this crashes downstream
import base64

raw = base64.b64decode("eyJ1c2VyX2lkIjogNDcxLCAicm9sZSI6ICJhZG1pbiJ9")

# TypeError: byte indices must be integers or slices, not str
user_id = raw["user_id"]

# ✅ decode bytes → str, then parse
import base64, json

raw = base64.b64decode("eyJ1c2VyX2lkIjogNDcxLCAicm9sZSI6ICJhZG1pbiJ9")
payload = json.loads(raw.decode("utf-8"))
print(payload["user_id"])  # 471
print(payload["role"])     # admin

Kesalahan 2: Menggunakan b64decode() pada input Base64 yang aman untuk URL

# ❌ JWT and OAuth tokens use '-' and '_' — not in standard alphabet
import base64

jwt_segment = "eyJ1c2VyX2lkIjogMjg5M30"
# binascii.Error or silently wrong bytes — unpredictable behaviour
base64.b64decode(jwt_segment)

# ✅ use urlsafe_b64decode() for any token with '-' or '_'
import base64, json

jwt_segment = "eyJ1c2VyX2lkIjogMjg5M30"
padded = jwt_segment + "=" * (-len(jwt_segment) % 4)
data = base64.urlsafe_b64decode(padded)
print(json.loads(data.decode("utf-8")))
# {'user_id': 2893}

Kesalahan 3: Tidak memperbaiki padding pada token yang sudah dipangkas

# ❌ JWTs and most URL-transmitted tokens strip '=' — this crashes
import base64

# Valid JWT payload segment — no padding, as per spec
segment = "eyJ0eXBlIjogImFjY2VzcyIsICJqdGkiOiAiMzgxIn0"
base64.urlsafe_b64decode(segment)
# binascii.Error: Incorrect padding

# ✅ add padding before every urlsafe_b64decode() call
import base64, json

segment = "eyJ0eXBlIjogImFjY2VzcyIsICJqdGkiOiAiMzgxIn0"
padded = segment + "=" * (-len(segment) % 4)
result = json.loads(base64.urlsafe_b64decode(padded).decode("utf-8"))
print(result["type"])  # access
print(result["jti"])   # 381

Kesalahan 4: Memanggil .decode("utf-8") pada data biner

# ❌ Binary files (PDF, PNG, ZIP) are not UTF-8 text — this crashes
import base64

# Base64-encoded PDF starts with JVBERi... (%PDF-)
pdf_b64 = "JVBERi0xLjQKJeLjz9MKNyAwIG9iago8PC9U..."
pdf_text = base64.b64decode(pdf_b64).decode("utf-8")
# UnicodeDecodeError: 'utf-8' codec can't decode byte 0xe2

# ✅ write binary directly to a file — no .decode() needed
import base64
from pathlib import Path

pdf_b64 = "JVBERi0xLjQKJeLjz9MKNyAwIG9iago8PC9U..."
pdf_bytes = base64.b64decode(pdf_b64)
Path("report_q1_2026.pdf").write_bytes(pdf_bytes)
print(f"Saved {len(pdf_bytes):,} bytes")

Mendekode File Base64 Besar di Python

Memuat file Base64 200 MB dengan Path.read_text() dan mendekodenya dalam satu panggilan akan mengalokasikan string yang dikodekan, byte yang didekode, dan representasi perantara secara bersamaan — dengan mudah menghabiskan memori di server yang terbatas atau fungsi Lambda. Untuk file yang lebih besar dari ~50–100 MB, gunakan pendekatan chunked sebagai gantinya.

Dekoding chunked ke disk (tanpa memuat seluruh file ke RAM)

import base64

def decode_large_b64_file(input_path: str, output_path: str, chunk_size: int = 65536) -> None:
    """
    Decode a large Base64 file in chunks to avoid loading the entire encoded
    string into memory. chunk_size must be a multiple of 4 to keep Base64
    block boundaries aligned across reads.
    """
    assert chunk_size % 4 == 0, "chunk_size must be a multiple of 4"

    bytes_written = 0
    with open(input_path, "rb") as src, open(output_path, "wb") as dst:
        while True:
            chunk = src.read(chunk_size)
            if not chunk:
                break
            # Strip whitespace that may appear in wrapped/multiline Base64
            chunk = chunk.strip()
            if chunk:
                dst.write(base64.b64decode(chunk))
                bytes_written += len(chunk)

    print(f"Decoded {bytes_written:,} Base64 bytes → {output_path}")

# Example: decode a 300 MB database snapshot stored as Base64
decode_large_b64_file("snapshot_2026_03_13.b64", "snapshot_2026_03_13.sql.gz")

Mendekode Base64 dengan base64.decodebytes() untuk data PEM / multi-baris

import base64

# base64.decodebytes() is designed for MIME / PEM Base64 that wraps at 76 chars.
# It silently ignores whitespace and newlines — perfect for certificate files.

with open("server_cert.pem", "rb") as f:
    pem_data = f.read()

# Strip PEM headers if present, then decode
lines = [
    line for line in pem_data.splitlines()
    if not line.startswith(b"-----")
]
raw_cert = base64.decodebytes(b"
".join(lines))
print(f"Certificate DER payload: {len(raw_cert):,} bytes")

Metode Dekoding Base64 Python — Perbandingan Cepat

Gunakan b64decode() sebagai default Anda. Beralih ke urlsafe_b64decode()segera saat Anda melihat - atau _ dalam input — karakter tersebut adalah tanda Base64 yang aman untuk URL yang tidak dapat disalahartikan. Gunakan pybase64 hanya setelah profiling mengonfirmasi bottleneck. Untuk pemeriksaan sekali pakai selama pengembangan, Dekoder Base64 ToolDeck menangani kedua alfabet dan memperbaiki padding secara otomatis — tidak perlu lingkungan Python.

Pertanyaan yang Sering Diajukan

Bagaimana cara mendekode string Base64 menjadi string biasa di Python?

Panggil base64.b64decode(encoded) untuk mendapatkan bytes, lalu panggil .decode("utf-8")pada hasilnya untuk mendapatkan str Python. Dua langkah ini selalu terpisah karena b64decode() hanya membalik alfabet Base64 — ia tidak mengetahui apakah konten aslinya UTF-8, Latin-1, atau biner. Jika data menggunakan encoding non-UTF-8, berikan nama codec yang benar ke .decode(), misalnya .decode("latin-1").

Mengapa saya mendapatkan "Incorrect padding" saat mendekode Base64 di Python?

String Base64 harus memiliki panjang yang merupakan kelipatan 4 karakter. JWT, token OAuth, dan data yang dikirim dalam URL sering menanggalkan padding = di akhir. Perbaikinya dengan menambahkan "=" * (-len(s) % 4) sebelum mendekode. Formula ini menambahkan tepat 0, 1, atau 2 karakter sesuai kebutuhan, dan merupakan no-op yang aman ketika string sudah dipadding dengan benar.

Apa perbedaan antara b64decode() dan urlsafe_b64decode() di Python?

Keduanya mendekode algoritma Base64 yang sama tetapi dengan alfabet yang berbeda untuk karakter ke-62 dan ke-63.b64decode() menggunakan + dan /; urlsafe_b64decode() menggunakan - dan _. Varian yang aman untuk URL didefinisikan dalam RFC 4648 §5 dan digunakan di mana pun Base64 harus bertahan dalam URL, header HTTP, atau nilai cookie tanpa percent-encoding. Mencampurnya menyebabkan binascii.Error atau output yang rusak secara diam-diam.

Bagaimana cara mendekode gambar yang dikodekan Base64 di Python?

Dekode ke bytes dengan base64.b64decode(encoded), lalu tulis byte tersebut langsung ke file — jangan panggil .decode("utf-8") pada data gambar. Jika inputnya adalah data URL (misalnya data:image/png;base64,iVBORw0KGgo…), hapus prefiks terlebih dahulu:

import base64
from pathlib import Path

# Data URL from an <img src="..."> or an API response
data_url = (
    "data:image/png;base64,"
    "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAAC0lEQVQI12NgAAIABQ=="
)

# Split off the "data:image/png;base64," prefix
_, encoded = data_url.split(",", 1)
image_bytes = base64.b64decode(encoded)
Path("avatar_jsmith.png").write_bytes(image_bytes)
print(f"Saved {len(image_bytes)} bytes")

Bisakah saya mendekode Base64 di Python tanpa mengimpor modul apa pun?

Secara teknis bisa, tetapi tidak ada alasan untuk melakukannya. Modul base64 adalah bagian dari pustaka standar Python, selalu tersedia, selalu terinstal — tidak memiliki dependensi dan fungsinya diimplementasikan dalam C. Mengimplementasikan ulang Base64 dari awal akan lebih lambat, lebih rentan error, dan lebih sulit dipelihara. Selalu gunakan import base64.

Bagaimana cara mendekode Base64 di Python ketika inputnya adalah bytes, bukan string?

base64.b64decode() menerima str, bytes, dan bytearray secara bergantian — tidak perlu konversi. Jika Anda menerima b"SGVsbG8=" dari socket atau pembacaan file, teruskan langsung. Perbaikan padding bekerja dengan cara yang sama dalam mode bytes: data + b"=" * (-len(data) % 4) saat beroperasi dalam mode bytes.

Alat Terkait

• Enkode Base64 — enkode teks atau file biner ke Base64 secara instan; berguna untuk menghasilkan fixture pengujian untuk kode dekoding Python Anda tanpa menjalankan skrip.
• Dekoder JWT — periksa header dan payload JWT tanpa menulis kode; payload didekode dengan Base64 yang aman untuk URL di balik layar, persis seperti yang ditunjukkan dalam contoh di atas.
• Dekode URL — percent-decode string kueri dan segmen jalur; sering diperlukan bersama dekoding Base64 saat mengurai URL callback OAuth atau payload webhook.
• Enkode URL — percent-encode karakter khusus; berguna saat Anda perlu menyematkan nilai yang dikodekan Base64 dengan aman di dalam parameter kueri URL.