Comment utiliser l'API GLM-5.3-Flash avec des images en entrée

GLM-5.3-Flash API : texte, images, streaming et outils

GLM-5.3-Flash est compatible OpenAI : pour effectuer un premier appel, pointez simplement un client existant vers une nouvelle URL de base et utilisez le modèle glm-5.3-flash. Son ajout majeur est l’entrée d’images dans la même requête que le texte.

Essayez Apidog dès aujourd’hui

Avant de commencer, consultez notre présentation de GLM-5.3-Flash. Si vous utilisez déjà GLM-5.3, lisez aussi le guide API de GLM-5.3 : GLM-5.3-Flash utilise un ID de modèle, une tarification et une prise en charge native des images différents.

Obtenir une clé API

Créez un compte sur z.ai, générez une clé API dans le tableau de bord, puis stockez-la dans une variable d’environnement :

export ZAI_API_KEY="votre-clé-ici"

L’URL de base de l’API standard est :

https://api.z.ai/api/paas/v4/

Les points de terminaison du plan de codage utilisent une URL distincte. Consultez notre guide Claude Code et Cline si vous configurez ces outils.

Effectuer un premier appel

Le SDK OpenAI officiel fonctionne directement.

Python

from openai import OpenAI
import os

client = OpenAI(
    [REDACTED CREDENTIAL],
    base_url="https://api.z.ai/api/paas/v4/",
)

response = client.chat.completions.create(
    model="glm-5.3-flash",
    messages=[
        {"role": "user", "content": "Explain what a KV cache is in two sentences."}
    ],
)

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

cURL

curl https://api.z.ai/api/paas/v4/chat/completions \
  -H "[REDACTED CREDENTIAL] $ZAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "glm-5.3-flash",
    "messages": [
      {"role": "user", "content": "Explain what a KV cache is in two sentences."}
    ]
  }'

Node.js

import OpenAI from "openai";

const client = new OpenAI({
  [REDACTED CREDENTIAL],
  baseURL: "https://api.z.ai/api/paas/v4/",
});

const response = await client.chat.completions.create({
  model: "glm-5.3-flash",
  messages: [
    { role: "user", content: "Explain what a KV cache is in two sentences." },
  ],
});

console.log(response.choices[0].message.content);

À part l’URL de base et l’ID de modèle, rien n’est spécifique à GLM. Cela facilite les benchmarks sur votre propre charge de travail.

Envoyer des images

Contrairement à GLM-5.3, GLM-5.3-Flash accepte des images via des blocs de contenu typés :

response = client.chat.completions.create(
    model="glm-5.3-flash",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": "This screenshot shows a rendering bug. What is wrong with the layout?",
                },
                {
                    "type": "image_url",
                    "image_url": {
                        "url": "https://example.com/screenshots/broken-layout.png"
                    },
                },
            ],
        }
    ],
)

Appliquez ces règles :

1. Utilisez une URL publique ou une URL de données base64. Pour une image locale ou privée :

   import base64

   with open("broken-layout.png", "rb") as f:
       encoded = base64.b64encode(f.read()).decode("utf-8")

   image_block = {
       "type": "image_url",
       "image_url": {"url": f"data:image/png;base64,{encoded}"},
   }

1. Ajoutez une image par bloc image_url. Pour comparer un design et son implémentation :

   content = [
       {"type": "text", "text": "Does the second image match the design in the first?"},
       {"type": "image_url", "image_url": {"url": design_data_url}},
       {"type": "image_url", "image_url": {"url": built_data_url}},
   ]

1. Placez les instructions avant les images. Le modèle lit les blocs séquentiellement.

Z.ai mentionne aussi les entrées vidéo et fichier avec ce mécanisme. Validez toutefois la vidéo avec vos propres médias avant de bâtir une fonctionnalité dessus.

Pour les workflows de capture d’écran vers le code et l’utilisation d’images avec de longs documents, consultez notre guide de vision GLM-5.3-Flash.

Contrôler l’effort de raisonnement

Utilisez reasoning_effort pour ajuster le coût et la profondeur de raisonnement :

response = client.chat.completions.create(
    model="glm-5.3-flash",
    messages=[{"role": "user", "content": "Refactor this function for clarity."}],
    extra_body={"reasoning_effort": "low"},
)

Valeurs disponibles :

• low : classification, extraction et traitements par lots sensibles aux coûts ;
• high : tâches intermédiaires ;
• max : valeur par défaut et option la plus coûteuse.

Avec le SDK Python OpenAI, passez ce paramètre via extra_body, car il ne fait pas partie du schéma OpenAI standard. En cURL, utilisez simplement un champ de premier niveau.

Paramètres d’échantillonnage recommandés

Cas d’utilisation	temperature	top_p
Général	1.0	0.95
Codage	0.95	1.0

Les écarts sont faibles, mais le profil codage est le premier à tester si vos sorties de code sont incohérentes.

Activer le streaming

Les sémantiques de streaming OpenAI restent identiques :

stream = client.chat.completions.create(
    model="glm-5.3-flash",
    messages=[{"role": "user", "content": "Write a bash script that rotates logs."}],
    stream=True,
)

for chunk in stream:
    delta = chunk.choices[0].delta.content
    if delta:
        print(delta, end="", flush=True)

Selon Artificial Analysis, GLM-5.3-Flash produit environ 49 jetons par seconde, contre environ 86 pour GLM-5.3. Son temps au premier jeton est d’environ 1,52 seconde : il commence rapidement, puis génère à un rythme régulier.

Utiliser l’appel d’outils

Définissez les outils avec le schéma OpenAI standard :

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_deployment_status",
            "description": "Returns the current status of a named deployment.",
            "parameters": {
                "type": "object",
                "properties": {
                    "service": {
                        "type": "string",
                        "description": "The service name, for example 'checkout-api'.",
                    }
                },
                "required": ["service"],
            },
        },
    }
]

response = client.chat.completions.create(
    model="glm-5.3-flash",
    messages=[{"role": "user", "content": "Is checkout-api healthy?"}],
    tools=tools,
)

call = response.choices[0].message.tool_calls[0]
print(call.function.name, call.function.arguments)

Z.ai indique un score AutomationBench de 48,8 pour GLM-5.3-Flash, contre 26,2 pour GLM-5.2. Ce sont des chiffres fournisseur, mais ils concordent avec un modèle optimisé pour les boucles d’appel d’outils.

Si vous possédez déjà une API, consultez notre guide pour transformer une spécification OpenAPI en outils d’agent.

Gérer les erreurs courantes

Limites de débit

Réessayez avec un backoff exponentiel et une gigue afin d’éviter des rafales de réessais synchronisés :

import time, random
from openai import RateLimitError

def call_with_retry(**kwargs):
    for attempt in range(5):
        try:
            return client.chat.completions.create(**kwargs)
        except RateLimitError:
            if attempt == 4:
                raise
            time.sleep((2 ** attempt) + random.random())

Débordement de contexte

La fenêtre de contexte atteint 1 million de jetons, mais les images consomment elles aussi du contexte. Comptez le budget d’entrée avant d’envoyer un long document accompagné d’images haute résolution.

Sortie tronquée

Si une réponse s’arrête brusquement, vérifiez finish_reason. La valeur length signifie que la limite de sortie a été atteinte, et non que le modèle a abandonné.

Lire l’utilisation des jetons

L’objet usage est la source fiable pour mesurer le coût réel :

print(response.usage.prompt_tokens, response.usage.completion_tokens)

Surveillez surtout completion_tokens. Avec reasoning_effort="max", les jetons de raisonnement sont facturés comme sortie, même si la réponse visible est courte. Comparez les niveaux d’effort avec vos propres prompts.

Tarification

Les tarifs catalogue annoncés sont :

Type de jeton	Prix par million
Entrée	0,15 $
Sortie	0,50 $
Entrée mise en cache	0,03 $

Une réduction de lancement de 50 % est valable jusqu’au 9 septembre 2026, ce qui ramène les tarifs à 0,075 $, 0,25 $ et 0,015 $.

Les prix diffèrent selon les revendeurs, notamment OpenRouter, Cloudflare Workers AI, Vercel AI Gateway et DeepInfra. Consultez notre analyse des prix, puis vérifiez le tarif du fournisseur réellement utilisé avant de définir votre budget.

Tester votre intégration

Testez au minimum trois requêtes : texte, image et appel d’outil. Conservez-les dans une collection, ajoutez des assertions sur les champs réellement lus par votre application et stockez la clé API comme variable d’environnement.

Apidog permet d’enregistrer ces requêtes, de réexécuter les scénarios et de comparer les réponses. Lorsque la promotion prend fin ou que vous envisagez un passage vers GLM-5.3, changez l’ID du modèle à un seul endroit et exécutez la même suite de tests.

FAQ

Quel est l’ID exact du modèle ?

glm-5.3-flash sur l’API Z.ai. Sur OpenRouter, utilisez z-ai/glm-5.3-flash.

Le SDK OpenAI fonctionne-t-il sans modification ?

Oui, pour les complétions de chat, le streaming et l’appel d’outils. Dans le SDK Python, les paramètres non standards comme reasoning_effort passent par extra_body.

Combien d’images puis-je envoyer dans une requête ?

Plusieurs, à raison d’un bloc image_url par image. La limite pratique dépend surtout de votre budget de contexte.

Pourquoi les réponses sont-elles lentes ou verbeuses ?

reasoning_effort vaut max par défaut. Passez à low pour les tâches qui n’exigent pas de délibération.

Quelle est la longueur maximale de sortie ?

Les sources divergent : OpenRouter indique 131 072 jetons et la carte Hugging Face 163 840 jetons. Vérifiez la limite auprès de votre fournisseur avant de dépendre de générations très longues.