Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Koda och skicka bilder i Base64

Lektion 5 av 12 Uppdaterad 2 november 2026 Utvecklare
På denna sida
  1. Varför använda Base64?
  2. När ska du använda URL kontra Base64?
  3. Koda en bild till Base64
  4. Format för Data URI
  5. Komplett exempel
  6. Koda bilder från andra källor
  7. Optimera storleken innan kodning
  8. Begränsningar att känna till
  9. Viktiga punkter

Varför använda Base64?

I föregående lektion lärde du dig hur man skickar bilder via en URL. De flesta bilder som bearbetas i affärssammanhang har dock ingen URL: en faktura som nyss kommit via e-post, en skärmdump genererad av ett automatiserat test eller ett foto taget av en operatör i en produktionslinje. Att publicera dessa filer på en internetåtkomlig server bara för att analysera dem vore absurt, och ofta förbjudet.

Här kommer kodning med Base64 in i bilden. Det omvandlar bildens binära data till en textsträng som du inkluderar direkt i din API-förfrågan, utan behov av en extern URL eller mellanliggande lagring.

När ska du använda URL kontra Base64?

KriteriumURLBase64
Bilder som redan är hostadeIdealtOnödigt
Lokala bilderOlämpligtIdealt
Dynamiskt genererade bilderOlämpligtIdealt
NätverkslatensBeror på servernIngen (inbäddad)
FörfrågningsstorlekLättviktigTyngre (~33 %)
Säkerhet/integritetOffentlig URLData inuti förfrågan

Regeln är enkel: om bilden är tillgänglig via en stabil URL, använd URL:n. Använd annars Base64.

Koda en bild till Base64

Inga beroenden krävs; Python tillhandahåller modulen base64 i sitt 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")

Läget "rb" när du öppnar filen är inte valfritt: att läsa en bild i textläge kommer att utlösa ett avkodningsfel. Räkna med långa strängar – kodningen ökar storleken med cirka 33 % jämfört med originalfilen, så en bild på 1 MB ger ungefär 1,33 MB text.

Format för Data URI

Den råa strängen räcker inte: API:t behöver veta bildformatet. Du måste därför presentera den som en data URI, vilket prefixar datan med dess MIME-typ:

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

De fyra användbara prefixen motsvarar de format som stöds:

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

Att ange en PNG som image/jpeg orsakar ett bearbetningsfel; därav detekteringsfunktionen i exemplet nedan.

Komplett exempel

Här är hela kedjan, från att läsa den lokala filen till 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)

Viktig poäng: fältet heter alltid image_url, även när det innehåller en data URI. Meddelandestrukturen ändras inte ett dugg jämfört med lektion 4; endast värdet skiljer sig.

Koda bilder från andra källor

En fil på disken är bara ett fall i mängden. Om din bild redan finns i minnet, som ett Pillow-objekt från en fångst eller ett bearbetningssteg, vore det en onödig omväg att skriva den till disk bara för att läsa tillbaka den direkt – en minnesbuffert fungerar utmärkt:

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)

Samma logik gäller för en bild som hämtas via HTTP som du inte vill lagra, till exempel för att den kommer från en länk med kort livslängd:

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

Optimera storleken innan kodning

Ett smartfonfoto väger idag mellan 4 och 8 MB, vilket blir nästan 10 MB när det är kodat. API:t kommer ändå att ändra storlek på det, som du såg i lektion 2: du skulle betala för överföringen i onödan. Ändra därför alltid storlek innan 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")

Att visa den slutliga storleken är inte bara dekorativt: behåll detta under dina tester, eftersom det omedelbart berättar för dig om din pipeline skickar 80 KB eller 8 MB vid varje anrop.

Begränsningar att känna till

Tre begränsningar följer med Base64. Den kodade bilden läggs till i HTTP-förfrågningskroppen, så bortom 10 MB riskerar du timeout. Kodning laddar också hela bilden i minnet: för batchbearbetning, hantera bilder en i taget snarare än att bygga en lista med tusen kodade strängar. Slutligen, till skillnad från URL:er, sänds Base64-bilder vidare i sin helhet vid varje förfrågan – att analysera samma faktura två gånger innebär att skicka den två gånger.

Viktiga punkter

  • Base64 är idealiskt för lokala eller dynamiskt genererade bilder
  • Data URI-formatet kombinerar MIME-typ och data: data:image/png;base64,...
  • Ändra storlek och komprimera dina bilder innan kodning för att optimera latens
  • Base64 ökar storleken med cirka 33 % – håll dina bilder under 10 MB
  • Använd URL när bilden redan är hostad, Base64 i alla andra fall