Vous avez probablement vu des chaînes Base64 éparpillées dans votre base de code — dans les jetons JWT, les balises HTML <img>, les en-têtes HTTP Authorization, ou les charges utiles JSON transportant des données de fichiers. Elles ressemblent à du charabia : SGVsbG8sIFdvcmxkIQ==. Mais il y a une raison simple pour laquelle elles existent, et une fois que vous la comprenez, Base64 cesse d'être mystérieux et devient un outil véritablement utile dans votre boîte à outils.

Ce qu'est réellement Base64

Base64 est un schéma d'encodage binaire vers texte. C'est tout. Il prend des données binaires arbitraires — des octets qui pourraient inclure des caractères nuls, des codes de contrôle, ou n'importe quelle valeur de 0 à 255 — et les représente en utilisant uniquement 64 caractères ASCII imprimables. Le résultat est une chaîne qui peut voyager en toute sécurité à travers n'importe quel canal textuel sans être corrompue ou mal interprétée.

La spécification formelle se trouve dans RFC 4648, publié par l'IETF. Il définit à la fois Base64 standard et la variante sécurisée pour les URL. Vaut la peine d'être mis en signet si vous avez jamais besoin de résoudre une discussion sur les règles de remplissage ou les choix d'alphabet.

L'alphabet Base64

L'alphabet de 64 caractères se compose de : majuscules A–Z (26 caractères), minuscules a–z (26 caractères), chiffres 0–9 (10 caractères), et deux symboles : + et /. Cela vous donne exactement 64 caractères — d'où le nom. Le signe = est utilisé comme caractère de remplissage à la fin lorsque la longueur de l'entrée n'est pas un multiple de 3.

text
ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/

Chaque caractère encode exactement 6 bits de données (2^6 = 64 valeurs possibles). C'est le mécanisme principal derrière l'encodage — et la raison de ce ~33% de surcharge de taille.

Comment fonctionne l'encodage

L'algorithme fonctionne par blocs de 3 octets → 4 caractères Base64. Trois octets = 24 bits. Divisez ces 24 bits en quatre groupes de 6 bits, et chaque groupe correspond à un caractère dans l'alphabet Base64.

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"

Lorsque l'entrée n'est pas divisible par 3, le remplissage entre en jeu. Deux octets restants deviennent trois caractères Base64 plus un =. Un octet restant devient deux caractères Base64 plus ==. Le remplissage indique simplement au décodeur combien d'octets sont réellement présents à la fin — ce n'est pas une partie des données elles-mêmes.

La surcharge de taille : chaque 3 octets d'entrée deviennent 4 caractères de sortie. C'est une augmentation de taille de 33%. Pour les petites chaînes, c'est négligeable. Pour les grandes fichiers binaires — une image de 10 Mo devient environ 13,3 Mo de Base64 — la surcharge est importante et vous devriez réfléchir à deux fois avant d'intégrer directement.

Encodage et décodage en JavaScript

Les navigateurs exposent btoa() et atob() en tant que globaux. Ils sont simples mais ont un piège : ils ne gèrent que les caractères Latin-1 (valeurs d'octets 0–255). Passez directement une chaîne Unicode multi-octets et vous obtiendrez une 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 — Utilisation de Buffer

Dans Node.js, l'approche idiomatique est l' API Buffer, qui gère Unicode correctement par défaut et est beaucoup plus propre que la solution de contournement du navigateur ci-dessus.

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 — Le module base64

La bibliothèque standard de Python inclut un module base64 qui gère l'encodage, le décodage et la variante sécurisée pour les URL. Les fonctions fonctionnent avec des objets bytes, donc vous devrez généralement encoder/décoder des chaînes avec un jeu de caractères explicite.

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))

Base64 sécurisé pour les URL

Le Base64 standard utilise + et /, qui sont des caractères spéciaux dans les URL. Déposez une chaîne Base64 standard dans un paramètre de requête et vous obtiendrez une corruption subtile à moins que vous ne l'encodiez d'abord en pourcentage. Le Base64 sécurisé pour les URL (également défini dans RFC 4648 §5) résout cela en remplaçant + par - et / par _. Les signes de remplissage = sont souvent omis entièrement dans les contextes d'URL.

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)

En Python, utilisez base64.urlsafe_b64encode() et base64.urlsafe_b64decode() — ils effectuent la substitution automatiquement.

Cas d'utilisation courants dans le monde réel

  • Intégration d'images dans HTML/CSS — un URI data: comme src="data:image/png;base64,iVBORw0KGgo..." élimine une requête HTTP séparée. Idéal pour les petites icônes et sprites ; pas idéal pour les grandes images en raison de la surcharge de taille de 33%.
  • Jetons JWT — les sections d'en-tête et de charge utile d'un JSON Web Token sont des objets JSON encodés en Base64 sécurisé pour les URL. Les trois parties séparées par des points que vous voyez dans un JWT sont Base64Url(en-tête).Base64Url(charge utile).Base64Url(signature).
  • Authentification HTTP de base — l'en-tête Authorization: Basic ... encode nom_utilisateur:mot_de_passe en Base64. Il est défini dans RFC 7617. Remarque : c'est de l'encodage, pas du chiffrement — utilisez toujours HTTPS.
  • Intégration de données binaires dans JSON — JSON n'a pas de type binaire, donc les fichiers, images, et certificats envoyés via API sont généralement encodés en Base64 dans un champ de chaîne. Voir les outils Fichier vers Base64 et Image vers Base64 pour ce flux de travail.
  • Pièces jointes de courrier électronique — MIME (le format sous-jacent du courrier électronique) utilise Base64 pour encoder les pièces jointes binaires afin qu'elles survivent à la transmission via des serveurs de relais de messagerie uniquement texte. Le problème original que Base64 a été conçu pour résoudre.
  • Stockage de données binaires dans des bases de données — lorsque vous devez stocker un petit blob (un certificat, une miniature) dans une colonne texte ou dans un document JSON, Base64 est le choix standard.

Base64 N'est PAS du chiffrement

Cela piège les gens constamment — surtout lors de la révision du code. Base64 est de l'encodage, pas du chiffrement. L'encodage est une transformation réversible qui change la représentation des données. Le chiffrement brouille les données à l'aide d'une clé secrète afin que seule une personne possédant la clé puisse l'inverser.

N'importe qui peut décoder une chaîne Base64 en quelques secondes — collez-la dans Décodeur Base64 et vous avez terminé. N'utilisez jamais Base64 pour "cacher" des valeurs sensibles comme des mots de passe, des clés API ou des données personnelles. Si vous avez besoin de confidentialité, utilisez un vrai chiffrement (AES, RSA, ou une bibliothèque comme Web Crypto API dans le navigateur, ou cryptography en Python).

À noter également : Base64 n'est pas de la compression. La sortie est toujours plus grande que l'entrée — d'environ un tiers. Si vous avez besoin de réduire la taille, compressez d'abord (gzip, Brotli, zstd), puis encodez en Base64 les octets compressés si le canal nécessite du texte.

Outils pour travailler avec Base64

Si vous travaillez avec Base64 au quotidien, avoir des outils rapides fait une vraie différence. Utilisez Encodeur Base64 pour encoder n'importe quelle chaîne de texte, Décodeur Base64 pour décoder et inspecter les valeurs Base64, Fichier vers Base64 pour convertir des fichiers binaires pour les charges utiles API ou le stockage, et Image vers Base64 pour générer des URI de données pour intégrer des images directement en HTML ou CSS.

Conclusion

Base64 existe pour résoudre un problème spécifique : faire passer des données binaires à travers des canaux uniquement texte sans corruption. Il le fait en mappant chaque 3 octets d'entrée à 4 caractères ASCII imprimables, en utilisant un alphabet de 64 caractères (A–Z, a–z, 0–9, +, /). Le résultat est sûr pour les e-mails, les en-têtes HTTP, les champs JSON et les URL (avec la variante sécurisée pour les URL). La contrepartie est une augmentation fixe de 33% de la taille. Ce n'est pas du chiffrement, ce n'est pas de la compression — c'est un encodage transparent et réversible. Une fois que vous avez intériorisé cela, vous saurez immédiatement quand l'utiliser et quand un outil différent convient mieux.

← All Base64 articles Browse all categories →