Tokens image : de 256 à 1792

Comment les images consomment des tokens

Quand vous envoyez une image à Grok, elle est convertie en tokens avant d’être analysée par le modèle. Contrairement au texte où un token correspond grossièrement à un mot, les tokens image dépendent de la taille de l’image et du niveau de détail demandé.

Comprendre cette mécanique est essentiel pour anticiper vos coûts et dimensionner vos requêtes.

La fourchette : 256 à 1792 tokens

Chaque image envoyée à l’API consomme entre 256 et 1792 tokens. Cette variation importante s’explique par plusieurs facteurs :

• La résolution de l’image : une image de 256x256 pixels consomme moins de tokens qu’une image de 4096x4096
• Le paramètre detail : low consomme le minimum, high consomme le maximum
• Le contenu de l’image : une image complexe avec beaucoup de détails peut entraîner une consommation plus élevée en mode auto

Suivre la consommation de tokens

L’API xAI fournit un décompte précis des tokens image dans la réponse. Vous le trouverez dans le champ usage :

{
  "usage": {
    "prompt_tokens": 2048,
    "completion_tokens": 150,
    "total_tokens": 2198,
    "prompt_tokens_details": {
      "image_tokens": 1024,
      "text_tokens": 1024
    }
  }
}

Le champ prompt_tokens_details.image_tokens vous indique exactement combien de tokens ont été consommés par les images dans votre requête. C’est un outil indispensable pour monitorer vos coûts en production.

Impact du niveau de détail sur les tokens

Le paramètre detail est le levier principal pour contrôler la consommation de tokens image :

# Même image, résultats très différents en tokens
# detail: low  → ~256 tokens image
# detail: auto → ~512-1024 tokens image (variable)
# detail: high → ~1024-1792 tokens image

En mode low, l’image est redimensionnée à une résolution réduite avant analyse. Le modèle reçoit moins d’informations mais consomme nettement moins de tokens.

En mode high, l’image est découpée en tuiles (tiles) à haute résolution. Chaque tuile est analysée séparément, ce qui multiplie le nombre de tokens mais permet de lire du texte fin ou de détecter des détails subtils.

Calculer le coût d’une requête multimodale

Pour estimer le coût d’une requête avec images, combinez les tokens texte et image :

def estimer_cout(nb_images, detail="auto", tokens_texte=500):
    # Estimation des tokens image par niveau
    tokens_image = {
        "low": 256,
        "auto": 768,   # moyenne estimée
        "high": 1536    # moyenne estimée
    }

    total_image = nb_images * tokens_image[detail]
    total = total_image + tokens_texte

    # Prix indicatif par million de tokens (input)
    prix_par_million = 3.00  # vérifier le prix actuel
    cout = (total / 1_000_000) * prix_par_million

    return {
        "tokens_image": total_image,
        "tokens_texte": tokens_texte,
        "tokens_total": total,
        "cout_estime": f"${cout:.4f}"
    }

Optimiser la consommation de tokens

Redimensionner avant l’envoi

Si votre image est très grande mais que vous n’avez pas besoin de la résolution maximale, redimensionnez-la avant de l’envoyer :

from PIL import Image
import io
import base64

def optimiser_image(chemin, taille_max=(1024, 1024)):
    img = Image.open(chemin)
    img.thumbnail(taille_max)

    buffer = io.BytesIO()
    img.save(buffer, format="JPEG", quality=85)
    buffer.seek(0)

    encoded = base64.standard_b64encode(buffer.read()).decode()
    return f"data:image/jpeg;base64,{encoded}"

Choisir le bon format

• JPEG : plus léger, idéal pour les photos et les images avec beaucoup de couleurs
• PNG : plus lourd mais sans perte, adapté aux captures d’écran et aux diagrammes avec du texte

Regrouper intelligemment

Si vous analysez un lot d’images, regroupez celles qui nécessitent le même niveau de détail dans des requêtes séparées plutôt que de mélanger low et high dans une même requête.

Monitorer en production

En production, loguez systématiquement les tokens image pour détecter les dérives :

response = client.responses.create(
    model="grok-4",
    input=[
        {"type": "input_image", "image_url": url},
        {"type": "input_text", "text": prompt}
    ]
)

# Logger les tokens
usage = response.usage
print(f"Tokens image : {usage.prompt_tokens_details.image_tokens}")
print(f"Tokens texte : {usage.prompt_tokens_details.text_tokens}")
print(f"Total prompt : {usage.prompt_tokens}")

Points clés à retenir

• Les images consomment entre 256 et 1792 tokens selon leur taille et le niveau de détail
• Le champ prompt_tokens_details.image_tokens donne le décompte exact
• Le paramètre detail est le levier principal pour contrôler la consommation
• Redimensionner les images avant l’envoi réduit les tokens sans sacrifier la qualité pour les tâches simples
• Monitorer les tokens image en production pour anticiper les coûts