Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Coder et envoyer des images en Base64

Les 5 van 12 Bijgewerkt op 2 november 2026 Ontwikkelaar
Op deze pagina
  1. Pourquoi utiliser le Base64 ?
  2. Quand utiliser une URL ou le Base64
  3. Encoder une image en Base64
  4. Format Data URI
  5. Exemple complet
  6. Encoder des images provenant d’autres sources
  7. Optimiser la taille avant l’encodage
  8. Limites à connaître
  9. Belangrijkste punten

Pourquoi utiliser le Base64 ?

Dans la leçon précédente, vous avez appris à envoyer des images via une URL. Cependant, la plupart des images traitées dans un contexte professionnel ne disposent pas d’URL : une facture qui vient d’arriver par e-mail, une capture d’écran générée par un test automatisé ou une photo prise par un opérateur sur une ligne de production. Publier ces fichiers sur un serveur accessible via Internet simplement pour les analyser serait absurde, et souvent interdit.

C’est ici qu’intervient l’encodage Base64. Il transforme les données binaires d’une image en une chaîne de texte que vous incluez directement dans votre requête API, sans avoir besoin d’une URL externe ni d’un hébergement intermédiaire.

Quand utiliser une URL ou le Base64

CritèreURLBase64
Images déjà hébergéesIdéalInutile
Images localesInadaptéIdéal
Images générées dynamiquementInadaptéIdéal
Latence réseauDépend du serveurAucune (intégré)
Taille de la requêteLégèrePlus lourde (~33 %)
Sécurité/confidentialitéURL publiqueDonnées dans la requête

La règle est simple : si l’image est accessible via une URL stable, utilisez l’URL. Sinon, utilisez le Base64.

Encoder une image en Base64

Aucune dépendance externe n’est requise ; Python fournit le module base64 dans sa bibliothèque standard :

import base64

def encode_image(file_path):
    """Encode un fichier image en chaîne Base64."""
    with open(file_path, "rb") as f:
        return base64.standard_b64encode(f.read()).decode("utf-8")

# Encoder une image locale
image_b64 = encode_image("captures/screenshot.png")
print(f"Longueur de la chaîne Base64 : {len(image_b64)} caractères")

Le mode "rb" lors de l’ouverture du fichier n’est pas optionnel : lire une image en mode texte provoquera une erreur de décodage. Attendez-vous à obtenir de longues chaînes : l’encodage augmente la taille d’environ 33 % par rapport au fichier original, donc une image de 1 Mo produit environ 1,33 Mo de texte.

Format Data URI

La chaîne brute ne suffit pas : l’API doit connaître le format de l’image. Vous devez donc la présenter sous forme de data URI, qui préfixe les données avec leur type MIME :

data:image/{format};base64,{base64_data}

Les quatre préfixes utilisables correspondent aux formats pris en charge :

  • data:image/jpeg;base64,...
  • data:image/png;base64,...
  • data:image/gif;base64,...
  • data:image/webp;base64,...

Annoncer un PNG comme image/jpeg provoque une erreur de traitement ; d’où la fonction de détection dans l’exemple suivant.

Exemple complet

Voici la chaîne complète, de la lecture du fichier local à la réponse du modèle :

import base64
import os
from mistralai.client import Mistral

def encode_image(chemin):
    """Encode une image locale en Base64."""
    with open(chemin, "rb") as f:
        return base64.standard_b64encode(f.read()).decode("utf-8")

# Déterminer le type MIME
def obtenir_mime(chemin):
    """Retourne le type MIME basé sur l'extension."""
    extensions = {
        ".jpg": "image/jpeg",
        ".jpeg": "image/jpeg",
        ".png": "image/png",
        ".gif": "image/gif",
        ".webp": "image/webp"
    }
    ext = os.path.splitext(chemin)[1].lower()
    return extensions.get(ext, "image/jpeg")

# Préparer l'image
chemin_image = "documents/facture-2024.png"
image_b64 = encode_image(chemin_image)
mime_type = obtenir_mime(chemin_image)
data_uri = f"data:{mime_type};base64,{image_b64}"

# Appeler l'API
client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

response = client.chat.complete(
    model="mistral-small-latest",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Extrayez toutes les informations de cette facture."},
                {"type": "image_url", "image_url": data_uri}
            ]
        }
    ]
)

print(response.choices[0].message.content)

Point clé : le champ s’appelle toujours image_url, même lorsqu’il contient un data URI. La structure du message ne change absolument pas par rapport à la leçon 4 ; seule la valeur diffère.

Encoder des images provenant d’autres sources

Un fichier sur le disque n’est qu’un cas parmi d’autres. Si votre image existe déjà en mémoire, sous forme d’objet Pillow issu d’une capture ou d’une étape de traitement, l’écrire sur le disque pour la relire immédiatement serait un détour inutile : un tampon en mémoire fonctionne parfaitement :

import base64
from io import BytesIO
from PIL import Image

def pil_to_base64(pil_image):
    """Convertit une image Pillow en data URI Base64."""
    buffer = BytesIO()
    pil_image.save(buffer, format="PNG")
    b64 = base64.standard_b64encode(buffer.getvalue()).decode("utf-8")
    return f"data:image/png;base64,{b64}"

# Exemple avec une image Pillow
img = Image.open("capture.png")
data_uri = pil_to_base64(img)

La même logique s’applique à une image récupérée via HTTP que vous ne souhaitez pas stocker, par exemple parce qu’elle provient d’un lien éphémère :

import base64
import requests

def url_to_base64(url):
    """Télécharge une image et la convertit en data URI."""
    response = requests.get(url, timeout=10)
    response.raise_for_status()
    content_type = response.headers.get("Content-Type", "image/jpeg")
    b64 = base64.standard_b64encode(response.content).decode("utf-8")
    return f"data:{content_type};base64,{b64}"

data_uri = url_to_base64("https://example.com/photo.jpg")

Optimiser la taille avant l’encodage

Une photo de smartphone pèse aujourd’hui entre 4 et 8 Mo, ce qui devient près de 10 Mo une fois encodée. L’API la redimensionnera de toute façon, comme vous l’avez vu à la leçon 2 : vous paieriez le transfert pour rien. Redimensionnez donc toujours avant d’encoder.

from PIL import Image
from io import BytesIO
import base64

def preparer_et_encoder(chemin, taille_max=1024, qualite=85):
    """Redimensionne, compresse et encode une image."""
    img = Image.open(chemin)

    # Redimensionner si nécessaire
    if max(img.size) > taille_max:
        img.thumbnail((taille_max, taille_max))

    # Convertir en JPEG pour réduire la taille
    buffer = BytesIO()
    img.convert("RGB").save(buffer, format="JPEG", quality=qualite)

    b64 = base64.standard_b64encode(buffer.getvalue()).decode("utf-8")
    taille_ko = len(buffer.getvalue()) / 1024
    print(f"Image encodée : {taille_ko:.0f} Ko")

    return f"data:image/jpeg;base64,{b64}"

data_uri = preparer_et_encoder("photo_haute_resolution.png")

Afficher la taille finale n’est pas seulement décoratif : conservez cette information lors de vos tests, car elle vous indiquera immédiatement si votre pipeline envoie 80 Ko ou 8 Mo à chaque appel.

Limites à connaître

Trois contraintes accompagnent le Base64. L’image encodée s’ajoute au corps de la requête HTTP, donc au-delà de 10 Mo, vous risquez des délais d’attente dépassés (timeouts). L’encodage charge également l’image entière en mémoire : pour un traitement par lots, traitez les images une par une plutôt que de construire une liste de mille chaînes encodées. Enfin, contrairement aux URL, les images en Base64 sont retransmises intégralement à chaque requête : analyser deux fois la même facture signifie l’envoyer deux fois.

Belangrijkste punten

  • Le Base64 est idéal pour les images locales ou générées dynamiquement
  • Le format data URI combine le type MIME et les données : data:image/png;base64,...
  • Redimensionnez et compressez vos images avant l’encodage pour optimiser la latence
  • Le Base64 augmente la taille d’environ 33 % — gardez vos images sous les 10 Mo
  • Utilisez une URL lorsque l’image est déjà hébergée, le Base64 dans tous les autres cas