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

Begränsningar: Format, storlek och gränser

Lektion 4 av 12 Uppdaterad 30 juli 2026 Nybörjare
På denna sida
  1. Grundregler
  2. Accepterade bildformat
  3. Maximal storlek: 20 MiB
  4. Antal bilder per förfrågan: Obegränsat
  5. Kompatibla modeller
  6. Felhantering
  7. Viktiga punkter

Grundregler

Innan du integrerar Grok Vision i dina applikationer måste du känna till de tekniska begränsningar som xAI:s API ställer upp. Om du ignorerar dessa gränser riskerar du tysta fel eller avvisade förfrågningar som kan vara svåra att felsöka i produktion.

Accepterade bildformat

xAI:s API accepterar två bildfilformat (tre filändelser: .jpg, .jpeg, .png):

  • JPG (eller JPEG) – det vanligaste formatet för fotografier
  • PNG – lämpligt för skärmdumpar, diagram och bilder med text

Alla andra format avvisas. Om du arbetar med WebP, GIF, BMP, TIFF, SVG eller HEIC-bilder måste du konvertera dem innan du skickar dem:

from PIL import Image

def convert_to_jpeg(source_path, output_path):
    img = Image.open(source_path)
    # Convert to RGB (required for JPEG)
    if img.mode in ("RGBA", "P"):
        img = img.convert("RGB")
    img.save(output_path, "JPEG", quality=90)

Vanlig fälla: RGBA-bilder

PNG-filer med transparens (alfakanal) accepteras som de är. Men om du konverterar dem till JPEG måste du först ta bort alfakanalen eftersom JPEG inte stöder transparens.

Maximal storlek: 20 MiB

Varje bild får inte överstiga 20 MiB (20 971 520 byte). Överskrider du detta avvisar API:t förfrågan.

Denna gräns gäller:

  • För den nedladdade filen vid användning av en URL
  • För den avkodade datan vid användning av Base64 (inte den kodade strängen i sig, som är cirka 33 % längre)

Kontrollera storleken innan sändning

import os

def check_size(image_path, max_mib=20):
    size = os.path.getsize(image_path)
    size_mib = size / (1024 * 1024)

    if size_mib > max_mib:
        raise ValueError(
            f"Image too large: {size_mib:.1f} MiB "
            f"(max {max_mib} MiB)"
        )
    return size_mib

Komprimera vid behov

För bilder som ligger nära gränsen kan du sänka JPEG-kvaliteten:

def compress_image(path, quality=80, max_size_mib=20):
    img = Image.open(path)
    buffer = io.BytesIO()
    img.save(buffer, "JPEG", quality=quality)

    while buffer.tell() > max_size_mib * 1024 * 1024 and quality > 20:
        quality -= 10
        buffer = io.BytesIO()
        img.save(buffer, "JPEG", quality=quality)

    buffer.seek(0)
    return buffer

Antal bilder per förfrågan: Obegränsat

Till skillnad från andra vision-API:er som begränsar antalet bilder per förfrågan, ställer xAI:s API inga gränser. Du kan skicka så många bilder du behöver i en enda förfrågan.

Tänk dock på att:

  • Varje bild förbrukar mellan 256 och 1792 token
  • Modellens totala kontext har en maximal storlek
  • Fler bilder innebär högre latens och kostnad

Praktisk rekommendation

Även om gränsen teoretiskt sett är obegränsad, bör du hålla dig till rimliga nivåer:

# Best practice: process in batches
def analyze_batch(images, batch_size=10):
    results = []
    for i in range(0, len(images), batch_size):
        batch = images[i:i + batch_size]
        input_data = []
        for img in batch:
            input_data.append({
                "type": "input_image",
                "image_url": img,
                "detail": "low"
            })
        input_data.append({
            "type": "input_text",
            "text": "Briefly describe each image."
        })

        response = client.responses.create(
            model="grok-4.5",
            input=input_data
        )
        results.append(response)
    return results

Kompatibla modeller

Bildförståelse är tillgänglig på grok-4.5 och högre. Tidigare modeller stöder inte denna funktion.

Kontrollera alltid vilken modell som används i din kod:

VISION_MODELS = ["grok-4.5", "grok-4.20-0309-reasoning"]

def supports_vision(model):
    return any(model.startswith(m) for m in VISION_MODELS)

Felhantering

Förutse fel relaterade till begränsningar genom att validera bilder innan du skickar dem:

def validate_image(path):
    errors = []

    # Check format
    extension = path.lower().rsplit(".", 1)[-1]
    if extension not in ("jpg", "jpeg", "png"):
        errors.append(f"Unsupported format: {extension}")

    # Check size
    size_mib = os.path.getsize(path) / (1024 * 1024)
    if size_mib > 20:
        errors.append(f"Too large: {size_mib:.1f} MiB (max 20)")

    # Check that it is a real image
    try:
        img = Image.open(path)
        img.verify()
    except Exception:
        errors.append("Corrupted file or not a valid image")

    return errors

Viktiga punkter

  • Endast formaten JPG/JPEG och PNG accepteras – konvertera andra format
  • Maximal storlek: 20 MiB per bild – komprimera vid behov
  • Antalet bilder per förfrågan är obegränsat, men varje bild förbrukar token
  • Endast modeller från grok-4.5 och uppåt stöder vision
  • Validera alltid bilder innan sändning för att undvika tysta fel