Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Kod og send billeder i Base64

Lektion 5 af 12 Opdateret 2. november 2026 Udvikler
På denne side
  1. Hvorfor bruge Base64?
  2. Hvornår skal du bruge URL kontra Base64?
  3. Kodning af et billede til Base64
  4. Data URI-format
  5. Komplet eksempel
  6. Kodning af billeder fra andre kilder
  7. Optimer størrelsen før kodning
  8. Grænser du skal kende
  9. Vigtige pointer

Hvorfor bruge Base64?

I den forrige lektion lærte du at sende billeder via en URL. De fleste billeder, der behandles i en forretningsmæssig kontekst, har dog ikke en URL: en faktura, der netop er modtaget pr. e-mail, et skærmbillede genereret af en automatiseret test, eller et foto taget af en operatør på en produktionslinje. Det ville være absurd og ofte forbudt at offentliggøre disse filer på en internettilgængelig server blot for at analysere dem.

Her kommer Base64-kodning ind i billedet. Den transformerer et billedes binære data til en tekststreng, som du kan inkludere direkte i din API-anmodning uden behov for en ekstern URL eller mellemliggende hosting.

Hvornår skal du bruge URL kontra Base64?

KriteriumURLBase64
Allerede hostede billederIdeeltUnødvendigt
Lokale billederIkke egnetIdeelt
Dynamisk genererede billederIkke egnetIdeelt
NetværkslatensAfhænger af serverenIngen (indlejret)
AnmodningsstørrelseLetvægtsTungere (~33 %)
Sikkerhed/privatlivOffentlig URLData inde i anmodningen

Reglen er enkel: Hvis billedet er tilgængeligt via en stabil URL, så brug URL’en. Ellers skal du bruge Base64.

Kodning af et billede til Base64

Der kræves ingen eksterne afhængigheder; Python leverer modulet base64 i sit standardbibliotek:

import base64

def encode_image(file_path):
    """Encode an image file to a Base64 string."""
    with open(file_path, "rb") as f:
        return base64.standard_b64encode(f.read()).decode("utf-8")

# Encode a local image
image_b64 = encode_image("captures/screenshot.png")
print(f"Base64 string length: {len(image_b64)} characters")

Tilstanden "rb" ved åbning af filen er ikke valgfri: Læsning af et billede i teksttilstand vil udløse en dekodningsfejl. Forvent lange strenge – kodning øger størrelsen med ca. 33 % sammenlignet med den oprindelige fil, så et billede på 1 MB producerer cirka 1,33 MB tekst.

Data URI-format

Den rå streng er ikke nok: API’et skal kende billedformatet. Du skal derfor præsentere det som en data URI, hvilket sætter et præfiks foran dataene med deres MIME-type:

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

De fire brugbare præfikser svarer til de understøttede formater:

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

Hvis du annoncerer et PNG som image/jpeg, opstår der en behandlingsfejl; heraf kommer detektionsfunktionen i eksemplet nedenfor.

Komplet eksempel

Her er hele kæden, fra læsning af den lokale fil til modellens svar:

import base64
import os
from mistralai.client import Mistral

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

# Determine MIME type
def obtenir_mime(chemin):
    """Return MIME type based on 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")

# Prepare the 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}"

# Call the 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": "Extract all information from this invoice."},
                {"type": "image_url", "image_url": data_uri}
            ]
        }
    ]
)

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

Vigtig pointe: Feltet hedder altid image_url, selv når det indeholder en data URI. Meddelelsesstrukturen ændrer sig ikke en smule i forhold til lektion 4; kun værdien er anderledes.

Kodning af billeder fra andre kilder

En fil på disken er blot ét tilfælde blandt mange. Hvis dit billede allerede eksisterer i hukommelsen, som et Pillow-objekt fra en optagelse eller et behandlingstrin, ville det være en unødvendig omvej at skrive det til disken blot for at læse det tilbage med det samme – en hukommelsesbuffer fungerer fint:

import base64
from io import BytesIO
from PIL import Image

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

# Example with a Pillow image
img = Image.open("capture.png")
data_uri = pil_to_base64(img)

Samme logik gælder for et billede hentet via HTTP, som du ikke ønsker at gemme, f.eks. fordi det stammer fra et kortlivet link:

import base64
import requests

def url_to_base64(url):
    """Download an image and convert it to a 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")

Optimer størrelsen før kodning

Et smartphone-foto vejer i dag 4 til 8 MB, hvilket bliver til næsten 10 MB, når det er kodet. API’et vil alligevel ændre størrelsen på det, som du så i lektion 2: du ville betale for overførslen for ingenting. Så ændr altid størrelsen før kodning.

from PIL import Image
from io import BytesIO
import base64

def preparer_et_encoder(chemin, taille_max=1024, qualite=85):
    """Resize, compress, and encode an image."""
    img = Image.open(chemin)

    # Resize if necessary
    if max(img.size) > taille_max:
        img.thumbnail((taille_max, taille_max))

    # Convert to JPEG to reduce size
    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"Encoded image: {taille_ko:.0f} KB")

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

data_uri = preparer_et_encoder("photo_haute_resolution.png")

At vise den endelige størrelse er ikke blot dekorativt: Behold det under dine tests, da det straks vil fortælle dig, om din pipeline sender 80 KB eller 8 MB ved hvert opkald.

Grænser du skal kende

Der følger tre begrænsninger med Base64. Det kodede billede lægges til HTTP-anmodningens body, så ud over 10 MB risikerer du timeouts. Kodning loader også hele billedet ind i hukommelsen: Ved batch-behandling skal du håndtere billeder ét ad gangen i stedet for at bygge en liste over tusind kodede strenge. Endelig bliver Base64-billeder, i modsætning til URL’er, videresendt i fuld længde ved hver anmodning – at analysere den samme faktura to gange betyder at sende den to gange.

Vigtige pointer

  • Base64 er ideelt til lokale eller dynamisk genererede billeder
  • Data URI-formatet kombinerer MIME-type og data: data:image/png;base64,...
  • Ændr størrelse og komprimer dine billeder før kodning for at optimere latensen
  • Base64 øger størrelsen med ca. 33 % – hold dine billeder under 10 MB
  • Brug URL, når billedet allerede er hostet, og Base64 i alle andre tilfælde