Encodage Base64 expliqué : quand et comment l'utiliser

31 mars 2026 · 12 min de lecture

Qu'est-ce que l'encodage Base64 ?

Base64 est un schéma d'encodage binaire vers texte qui convertit des données binaires en une chaîne de caractères ASCII. Il représente les données binaires en utilisant seulement 64 caractères imprimables : A-Z, a-z, 0-9, + et /, avec = utilisé pour le remplissage.

Cet encodage permet de transmettre en toute sécurité des données binaires via des canaux texte uniquement comme les e-mails, les API JSON, les documents XML et le HTML. Sans Base64, les données binaires pourraient être corrompues ou mal interprétées par les systèmes qui attendent du texte.

Le nom « Base64 » vient de l'alphabet de 64 caractères utilisé dans l'encodage. Contrairement au chiffrement ou au hachage, Base64 n'est pas une mesure de sécurité — c'est simplement une façon de représenter des données binaires sous forme de texte. N'importe qui peut décoder Base64 vers sa forme originale sans aucune clé ou mot de passe.

Base64 est omniprésent dans le développement web moderne :

• URI de données en HTML et CSS pour intégrer des images
• Pièces jointes d'e-mails utilisant l'encodage MIME
• JWT (JSON Web Tokens) pour l'authentification
• En-têtes d'authentification API (Basic Auth)
• Stockage de données binaires en JSON ou XML
• Encodage de téléchargements de fichiers dans les formulaires web
• Fichiers de certificats et de clés (format PEM)

Comprendre quand et comment utiliser Base64 est une compétence fondamentale pour tout développeur travaillant avec des API web, la transmission de données ou la gestion de fichiers.

Comment fonctionne Base64 en coulisses

Le processus d'encodage convertit chaque 3 octets (24 bits) d'entrée en 4 caractères Base64 (6 bits chacun). C'est la relation mathématique de base qui définit Base64.

Voici le processus étape par étape avec un exemple concret :

# Étape 1 : Prendre 3 octets d'entrée
Texte d'entrée : "Hi!"
Binaire : 01001000 01101001 00100001

# Étape 2 : Diviser en groupes de 6 bits
010010 000110 100100 100001

# Étape 3 : Mapper chaque groupe de 6 bits à l'alphabet Base64
010010 → S (18)
000110 → G (6)
100100 → k (36)
100001 → h (33)

# Résultat : "Hi!" → "SGkh"

L'alphabet Base64 mappe chaque valeur de 6 bits (0-63) à un caractère spécifique :

Comprendre le remplissage

Lorsque la longueur d'entrée n'est pas divisible par 3, Base64 ajoute un remplissage avec des caractères = pour rendre la longueur de sortie divisible par 4. Cela garantit un décodage correct.

# Exemples de remplissage
"A"    → "QQ=="   (1 octet → 2 caractères + ==)
"AB"   → "QUI="   (2 octets → 3 caractères + =)
"ABC"  → "QUJD"   (3 octets → 4 caractères, pas de remplissage)

Le remplissage indique au décodeur combien d'octets étaient dans l'entrée originale. Sans lui, le décodeur ne saurait pas s'il doit s'attendre à 1, 2 ou 3 octets dans le groupe final.

Pourquoi 6 bits par caractère ?

Le choix de 6 bits par caractère est délibéré. Avec 6 bits, vous pouvez représenter 2^6 = 64 valeurs différentes, ce qui correspond parfaitement à l'alphabet de 64 caractères.

Cela signifie également que 3 octets (24 bits) se divisent uniformément en quatre morceaux de 6 bits, créant un schéma d'encodage efficace avec une surcharge minimale.

Encodage et décodage en pratique

La plupart des langages de programmation fournissent des fonctions intégrées ou des bibliothèques standard pour l'encodage et le décodage Base64. Voici des exemples pratiques dans les langages populaires :

JavaScript / Node.js

// Navigateur (moderne)
const text = "Hello, World!";
const encoded = btoa(text);
console.log(encoded); // SGVsbG8sIFdvcmxkIQ==

const decoded = atob(encoded);
console.log(decoded); // Hello, World!

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

const decoded = Buffer.from(encoded, 'base64').toString();
console.log(decoded); // Hello, World!

Python

import base64

# Encodage
text = "Hello, World!"
encoded = base64.b64encode(text.encode())
print(encoded)  # b'SGVsbG8sIFdvcmxkIQ=='

# Décodage
decoded = base64.b64decode(encoded).decode()
print(decoded)  # Hello, World!

Java

import java.util.Base64;

// Encodage
String text = "Hello, World!";
String encoded = Base64.getEncoder().encodeToString(text.getBytes());
System.out.println(encoded); // SGVsbG8sIFdvcmxkIQ==

// Décodage
byte[] decoded = Base64.getDecoder().decode(encoded);
System.out.println(new String(decoded)); // Hello, World!

Ligne de commande

# Encoder
echo -n "Hello, World!" | base64
# SGVsbG8sIFdvcmxkIQ==

# Décoder
echo "SGVsbG8sIFdvcmxkIQ==" | base64 -d
# Hello, World!

# Encoder un fichier
base64 image.png > image.txt

# Décoder un fichier
base64 -d image.txt > image.png

Pour des tâches rapides d'encodage et de décodage, vous pouvez utiliser notre outil Encodeur Base64 directement dans votre navigateur sans écrire de code.

Cas d'utilisation courants pour Base64

L'encodage Base64 résout des problèmes spécifiques dans la transmission et le stockage de données. Voici les scénarios les plus courants où vous rencontrerez ou devrez utiliser Base64 :

1. URI de données pour les images intégrées

Les URI de données vous permettent d'intégrer des images directement dans le HTML ou le CSS sans requêtes HTTP séparées. C'est particulièrement utile pour les petites icônes, logos ou SVG en ligne.

<img src="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAUA..." alt="Point rouge" />

/* CSS */
.icon {
  background-image: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0i...);
}

Les avantages incluent la réduction des requêtes HTTP et la disponibilité garantie (pas de liens d'images cassés). Cependant, cela augmente la taille des fichiers HTML/CSS et empêche la mise en cache séparée de l'image par le navigateur.

2. Pièces jointes d'e-mails (MIME)

Les protocoles de messagerie ont été conçus pour le texte ASCII 7 bits. L'encodage Base64 permet aux pièces jointes binaires comme les PDF, images et documents d'être transmises en toute sécurité via les systèmes de messagerie.

La norme MIME (Multipurpose Internet Mail Extensions) utilise Base64 pour encoder les pièces jointes dans les messages électroniques. Ceci est géré automatiquement par les clients et serveurs de messagerie.

3. Authentification API

L'authentification HTTP Basic encode les identifiants en Base64 dans l'en-tête Authorization :

// Nom d'utilisateur : user, Mot de passe : pass
// Combiné : user:pass
// Base64 : dXNlcjpwYXNz

Authorization: Basic dXNlcjpwYXNz

Rappel : Base64 n'est pas du chiffrement. Basic Auth sur HTTP n'est pas sécurisé. Utilisez toujours HTTPS lors de la transmission d'identifiants.

4. JSON Web Tokens (JWT)

Les JWT utilisent l'encodage Base64URL (une variante sécurisée pour les URL) pour les sections d'en-tête et de charge utile :

// Structure JWT : header.payload.signature
eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c

Chaque section est du JSON encodé en Base64URL, rendant les JWT lisibles et transmissibles dans les URL et les en-têtes HTTP.

5. Stockage de données binaires dans les bases de données

Certaines bases de données ou formats de données (comme JSON ou XML) ne gèrent pas bien les données binaires. L'encodage Base64 vous permet de stocker des données binaires sous forme de texte :

{
  "user_id": 12345,
  "profile_image": "iVBORw0KGgoAAAANSUhEUgAAAAUA...",
  "document": "JVBERi0xLjQKJeLjz9MKMSAwIG9iago8..."
}

C'est courant dans les bases de données NoSQL, les fichiers de configuration et les réponses API qui doivent inclure des données binaires.

6. Fichiers de certificats et de clés

Le format PEM (Privacy Enhanced Mail) utilise Base64 pour encoder les certificats, clés privées et clés publiques :

-----BEGIN CERTIFICATE-----
MIIDXTCCAkWgAwIBAgIJAKL0UG+mRKmzMA0GCSqGSIb3DQEBCwUAMEUxCzAJBgNV
BAYTAkFVMRMwEQYDVQQIDApTb21lLVN0YXRlMSEwHwYDVQQKDBhJbnRlcm5ldCBX
...
-----END CERTIFICATE-----

Cela rend les certificats et clés portables entre différents systèmes et faciles à copier-coller.

Base64 dans les API et le développement web

Les API web utilisent fréquemment Base64 à diverses fins. Comprendre ces modèles vous aide à travailler efficacement avec des API tierces et à concevoir les vôtres.

API de téléchargement de fichiers

De nombreuses API acceptent les téléchargements de fichiers sous forme de chaînes encodées en Base64 dans les charges utiles JSON :

POST /api/upload
Content-Type: application/json

{
  "filename": "document.pdf",
  "content": "JVBERi0xLjQKJeLjz9MK...",
  "encoding": "base64"
}

Cette approche fonctionne bien pour les petits fichiers mais devient inefficace pour les gros téléchargements. Pour les fichiers de plus de 1-2 Mo, envisagez plutôt d'utiliser multipart/form-data ou des téléchargements binaires directs.

Charges utiles de webhooks

Les webhooks incluent souvent des données encodées en Base64 pour garantir que le contenu binaire survive à la sérialisation JSON :

{
  "event": "document.signed",
  "document_id": "doc_123",
  "signed_pdf": "JVBERi0xLjQKJeLjz9MK...",
  "timestamp": "2026-03-31T10:30:00Z"
}

GraphQL et Base64

GraphQL utilise couramment Base64 pour la pagination basée sur les curseurs et l'encodage d'ID complexes :

query {
  users(first: 10, after: "Y3Vyc29yOjEwMA==") {
    edges {
      cursor
      node {
        id  # Souvent encodé en Base64 : "VXNlcjoxMjM="
        name
      }
    }
  }
}

La spécification Relay a popularisé ce modèle, utilisant Base64 pour encoder les positions de curseur et les ID globaux.

API de navigateur et Base64

Les API de navigateur modernes fonctionnent fréquemment avec Base64 :

// Canvas vers Base64
const canvas = document.getElementById('myCanvas');
const dataURL = canvas.toDataURL('image/png');
// data:image/png;base64,iVBORw0KGgo...

// Fichier vers Base64
const file = document.getElementById('fileInput').files[0];
const reader = new FileReader();
reader.onload = (e) => {
  const base64 = e.target.result.split(',')[1];
  console.log(base64);
};
reader.readAsDataURL(file);

// Fetch avec authentification Base64
fetch('/api/data', {
  headers: {
    'Authorization': 'Basic ' + btoa('username:password')
  }
});

Considérations de performance et surcharge

L'encodage Base64 comporte des compromis qui affectent les performances, la bande passante et le stockage. Comprendre ceux-ci vous aide à prendre des décisions éclairées sur quand l'utiliser.

Surcharge de taille

Base64 augmente la taille des données d'environ 33%. Voici le calcul :

• 3 octets d'entrée → 4 octets de sortie
• Surcharge : (4 - 3) / 3 = 33,33%
• Une image de 300 Ko devient ~400 Ko une fois encodée
• Un fichier de 1 Mo devient ~1,33 Mo une fois encodé

Cette surcharge compte pour les environnements à bande passante limitée, les applications mobiles et les transferts de gros fichiers.

Vitesse de traitement

L'encodage et le décodage Base64 nécessitent des cycles CPU. Pour de petites quantités de données, c'est négligeable. Pour les gros fichiers ou les systèmes à haut débit, cela peut devenir un goulot d'étranglement.

Les implémentations modernes sont hautement optimisées, mais vous devriez quand même faire des tests de performance si c'est critique :

// Exemple de benchmark JavaScript
const data = new Uint8Array(1024 * 1024); // 1Mo
crypto.getRandomValues(data);

console.time('encode');
const encoded = btoa(String.fromCharCode(...data));
console.timeEnd('encode');

console.time('decode');
const decoded = atob(encoded);
console.timeEnd('decode');

Utilisation de la mémoire

Les opérations Base64 nécessitent généralement de conserver à la fois les données originales et encodées en mémoire simultanément. Pour les gros fichiers, cela peut doubler les besoins en mémoire pendant l'encodage/décodage.

Envisagez des approches en streaming pour les gros fichiers :

// Exemple de streaming Node.js
const fs = require('fs');
const { Transform } = require('stream');

fs.createReadStream('large-file.bin')
  .pipe(new Transform({
    transform(chunk, encoding, callback) {
      callback(null, chunk.toString('base64'));
    }
  }))
  .pipe(fs.createWriteStream('large-file.b64'));