uToolGo Utility Tools, Go Further

Encodeur/Décodeur Base64

Un encodeur/décodeur Base64 gratuit en ligne pour un encodage et un décodage rapides, offrant une gestion sûre de l'UTF-8, une conversion adaptée aux URL, un remplissage automatique, des statistiques en temps réel et une fonctionnalité de copie sécurisée. Fournit des exemples de code multilingues, la génération d'URI de données, des guides d'utilisation détaillés et des questions fréquentes. Interface conviviale avec saisie bidirectionnelle, accessibilité au clavier et conception adaptée aux mobiles. Aucun téléchargement requis, fonctionne directement dans votre navigateur.

Encoder (Texte → Base64)

Décoder (Base64 → Texte)

Comment utiliser

Base64 encode les données binaires en ASCII pour une transmission et un stockage sûrs. La taille augmente d'environ 33 %.
Encoder : Convertir du texte brut en Base64 pour une transmission sécurisée.
Décoder : Restaurer le texte original à partir d'une chaîne Base64.

Fonctionnalités

  • Compatible UTF-8 : Gère correctement les caractères non-ASCII (enveloppé avec encodeURIComponent/unescape).
  • Support URL-safe : Bascule en un clic entre + / → - _, suppression optionnelle du remplissage =.
  • Pré-traitement avant décodage : Ignore les espaces, convertit automatiquement au format URL-safe et ajoute automatiquement le remplissage =.
  • Interaction en temps réel : Le traitement est instantané, avec affichage des statistiques de longueur et de croissance.
  • Utilisabilité : Copie rapide, saisie bidirectionnelle entre les champs, accessible au clavier, adaptée aux mobiles.
  • Thème cohérent : Pas de classes dark: Tailwind — entièrement stylisé avec les thèmes DaisyUI.

Exemples rapides

Texte original :
Hello, World!
Base64:
SGVsbG8sIFdvcmxkIQ==

Qu'est-ce que le Base64 ?

Base64 est une méthode d'encodage des données binaires en texte ASCII, couramment utilisée pour transmettre des images ou le contenu de fichiers via des protocoles basés sur le texte tels que JSON, XML et HTTP.

Elle mappe chaque groupe de 3 octets en 4 caractères imprimables, entraînant généralement une augmentation de taille d'environ 33 %.

Le Base64 standard utilise A–Z, a–z, 0–9, +, / et le caractère de remplissage = ; la variante URL-safe remplace + et / par - et _ pour éviter les problèmes d'échappement dans les URLs.

Cas d'usage courants

  • Intégrer des images ou de petits fichiers sous forme de Data URIs.
  • Transférer des données binaires entre le client et le serveur (ex. : textes chiffrés, flux compressés).
  • Convertir le texte en format imprimable pour éviter les incohérences d'encodage ou les caractères invisibles.

FAQs et notes importantes

  • Jeu de caractères : Dans les environnements web, encodage préalable du texte en UTF-8 (cet outil inclut automatiquement cette étape).
  • URL-safe : Pour les paramètres ou chemins d'URL, privilégiez la variante URL-safe et envisagez de supprimer les caractères de remplissage.
  • Remplissage : Certaines implémentations permettent d'omettre les = ; lors du décodage, complétez automatiquement jusqu'à un multiple de 4 caractères.
  • Sauts de ligne : Le MIME Base64 peut inclure des sauts de ligne ; sélectionnez "Ignorer les espaces" lors du décodage pour les gérer.

Comment encoder/décoder du Base64 dans les langages de programmation

JavaScript
Texte → Base64 (sûr UTF-8) 
const encoded = btoa(unescape(encodeURIComponent(text)));
// Sûr pour URL
const urlSafe = encoded.replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/g, '');
Décoder (Base64 → Texte)
// Prétraitement : remplacer -_ par +/
let b64 = input.replace(/-/g, '+').replace(/_/g, '/');
if (b64.length % 4 !== 0) b64 = b64.padEnd(b64.length + (4 - (b64.length % 4)), '=');
const text = decodeURIComponent(escape(atob(b64)));
PHP
Encoder (Texte → Base64)
$encoded = base64_encode($text);
// Sûr pour URL
$urlSafe = rtrim(strtr($encoded, '+/', '-_'), '=');
Décoder (Base64 → Texte)
$b64 = strtr($input, '-_', '+/');
// Ajout automatique de '=' comme remplissage
if (strlen($b64) % 4 !== 0) $b64 .= str_repeat('=', 4 - (strlen($b64) % 4));
$text = base64_decode($b64);
Python
Encoder (Texte → Base64)
import base64

encoded = base64.b64encode(text.encode('utf-8')).decode('ascii')
# Encodage sûr pour URL (supprimer le remplissage)
url_safe = encoded.replace('+','-').replace('/','_').rstrip('=')
Décoder (Base64 → Texte)
import base64

def b64_decode(s: str) -> str:
    s = s.replace('-','+').replace('_','/')
    s += '=' * (-len(s) % 4)  # Ajout automatique de '=' comme remplissage
    return base64.b64decode(s).decode('utf-8')
Go
Encoder (Texte → Base64)
import (
    "encoding/base64"
)

enc := base64.StdEncoding.EncodeToString([]byte(text))
// Encodage sûr pour URL (sans remplissage)
urlEnc := base64.RawURLEncoding.EncodeToString([]byte(text))
Décoder (Base64 → Texte)
import (
    "encoding/base64"
)

decBytes, err := base64.StdEncoding.DecodeString(enc)
// Décodage sûr pour URL (sans remplissage)
decURL, err2 := base64.RawURLEncoding.DecodeString(urlEnc)
Rust
Encoder (Texte → Base64)
use base64::{engine::general_purpose, Engine as _};

let enc = general_purpose::STANDARD.encode(text.as_bytes());
// Encodage sûr pour URL (sans remplissage)
let url_enc = general_purpose::URL_SAFE_NO_PAD.encode(text.as_bytes());
Décoder (Base64 → Texte)
use base64::{engine::general_purpose, Engine as _};

let dec_bytes = general_purpose::STANDARD.decode(&enc).unwrap();
let dec = String::from_utf8(dec_bytes).unwrap();

let url_dec = String::from_utf8(
    general_purpose::URL_SAFE_NO_PAD.decode(&url_enc).unwrap()
).unwrap();
Dépendance Cargo : base64 = "0.22"
Java
Encoder (Texte → Base64)
import java.nio.charset.StandardCharsets;
import java.util.Base64;

String enc = Base64.getEncoder().encodeToString(text.getBytes(StandardCharsets.UTF_8));
// Encodage sûr pour URL (sans remplissage)
String urlEnc = Base64.getUrlEncoder().withoutPadding().encodeToString(text.getBytes(StandardCharsets.UTF_8));
Décoder (Base64 → Texte)
import java.nio.charset.StandardCharsets;
import java.util.Base64;

String dec = new String(Base64.getDecoder().decode(enc), StandardCharsets.UTF_8);
String urlDec = new String(Base64.getUrlDecoder().decode(urlEnc), StandardCharsets.UTF_8);

Exemples d'URI de données

Intégrer des images ou de petits fichiers sous forme de Data URIs :

data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAA...

Remarque : Évitez d'utiliser les URI de données pour les fichiers volumineux, car ils augmentent considérablement la taille du HTML/JSON et dégradent les performances.

Rechercher des outils →