DEV Community: Antoine Laurent

Gemini Omni 1.1 Flash : les nouveautés du modèle vidéo GA de Google

Antoine Laurent — Fri, 28 Aug 2026 08:47:02 +0000

Google a rendu son modèle vidéo conversationnel généralement disponible le 27 août 2026. Son identifiant est gemini-omni-1.1-flash. Il remplace le point de terminaison gemini-omni-flash-preview, lancé en préversion publique le 30 juin. Si vous utilisez cette préversion, migrez avant le 30 septembre 2026 : Google désactivera alors le point de terminaison de préversion.

Essayez Apidog dès aujourd’hui

La version GA apporte quatre nouveautés importantes pour la production : extension de scène jusqu’à 40 secondes, contrôle de la première et de la dernière image, mode brouillon 360p et mise à l’échelle 4K. Cet article couvre les capacités, les limites, le coût, les environnements disponibles et la migration depuis la préversion.

Pour découvrir l’historique de la famille Omni et les raisons du développement d’un modèle vidéo orienté raisonnement, consultez Qu’est-ce que Gemini Omni ?. La suite se concentre sur la version 1.1.

Ce que fait Gemini Omni 1.1 Flash

Omni 1.1 Flash accepte du texte, des images et des vidéos en entrée, puis génère une vidéo. Il s’exécute via l’API Interactions, et non generateContent. Cette interface permet d’envoyer des requêtes de suivi dans la même interaction : vous pouvez donc modifier une vidéo générée sans la télécharger à nouveau.

Les cinq tâches prises en charge sont :

Texte vers vidéo : générer un clip à partir d’une invite.
Image vers vidéo : utiliser une image comme première image ou comme référence stylistique.
Référence vers vidéo : utiliser jusqu’à trois clips de référence de trois secondes pour guider le mouvement, l’apparence et la cohérence des personnages.
Modifier : transformer une vidéo déjà générée dans une interaction conversationnelle.
Étendre : ajouter 10 secondes à la fin d’un clip.

L’audio des clips de référence est ignoré. Le modèle les analyse uniquement pour le mouvement et l’apparence.

Étendre une scène avec 10 secondes de contexte

La principale amélioration concerne l’extension de scène. La préversion n’analysait que la dernière seconde du clip. Cela suffisait à conserver une palette de couleurs, mais pas la continuité des personnages ou des mouvements de caméra.

Omni 1.1 analyse jusqu’à 10 secondes de contexte antérieur, ce qui améliore la cohérence visuelle et l’adhérence narrative. Vous pouvez ajouter des segments de 10 secondes, jusqu’à une durée cumulative de 40 secondes.

À retenir :

l’extension se fait uniquement à la fin du clip ;
vous ne pouvez pas insérer une séquence au milieu ni en ajouter au début ;
une vidéo téléchargée est limitée à 10 secondes en entrée ;
dans une interaction multi-tour, l’état précédent est conservé.

Le guide de l’extension de scène jusqu’à 40 secondes détaille la structure des requêtes et les points où les raccords peuvent apparaître.

Contrôler la première et la dernière image

Vous pouvez désormais fournir une image de départ, une image de fin et une invite décrivant le mouvement entre les deux. Le modèle génère la séquence intermédiaire.

Cette fonction convient notamment aux :

orbites de caméra ;
transitions avec zoom ;
clips en boucle ;
animations reliant deux états visuels précis.

Pour un produit vidéo, cette approche est plus prévisible que le texte vers vidéo seul. Deux images fixes définissent les contraintes de départ et d’arrivée ; le modèle n’a plus qu’à résoudre la transition.

Le mode brouillon 360p réduit le coût d’itération

Omni 1.1 génère des prévisualisations 360p jusqu’à 60 % plus rapidement que le 720p, pour un tiers du coût. Le flux de travail recommandé est simple :

tester les invites en 360p ;
sélectionner la version satisfaisante ;
générer la sortie finale en 720p, 1080p ou 4K.

La génération vidéo étant facturée à la seconde, cette approche évite de payer le prix fort pour des essais qui seront abandonnés. La répartition complète des prix détaille le calcul par seconde.

La résolution se définit dans le format de réponse. Les sorties 1080p et 4k sont des mises à l’échelle des images générées, et non des rendus natifs.

Où utiliser Omni 1.1 Flash

Le modèle est disponible via :

l’API Gemini dans Google AI Studio ;
l’API Gemini Enterprise Agent Platform ;
Google Flow, pour les abonnés AI Plus, Pro et Ultra ;
l’application Gemini, notamment pour l’extension de scène.

Google a également annoncé des partenaires qui utilisent le modèle dans leurs produits : Adobe Firefly, Figma Weave, Runway et GMI Cloud.

Pas de niveau gratuit sur l’API

Contrairement aux modèles texte Flash, pour lesquels AI Studio propose une offre gratuite à débit limité, Omni est facturé dès la première requête. Chaque seconde de vidéo générée est payante.

Le modèle est gratuit sur YouTube Shorts et YouTube Create, mais ces produits disposent de limites distinctes. Le récapitulatif des accès gratuits compare les différentes options.

Limites à vérifier avant l’intégration

Avant de construire une fonctionnalité autour du modèle, vérifiez les points suivants :

Paramètres de génération limités : les instructions système, temperature, top_p, les séquences d’arrêt et les invites négatives ne sont pas pris en charge. Pour exclure un élément, indiquez-le dans l’invite standard.
Restrictions régionales : le téléchargement et l’édition de vidéos ne sont pas disponibles dans l’Espace économique européen, en Suisse et au Royaume-Uni. L’édition d’images contenant des mineurs est également restreinte. Les vidéos générées par le modèle restent modifiables dans ces régions.
Personnes reconnaissables : la modification de certains individus identifiables est bloquée.
Dialogue sur une vidéo téléchargée : vous pouvez étendre silencieusement un clip téléchargé ou travailler dans une interaction multi-tour, mais vous ne pouvez pas ajouter de dialogue en étendant la vidéo d’une autre personne.
Une seule vidéo pour le raisonnement : le modèle ne raisonne pas sur plusieurs vidéos d’entrée.
Langues : l’anglais est entièrement pris en charge. Google indique que les autres langues ne sont pas testées.

Chaque sortie contient un filigrane SynthID invisible à l’œil nu et détectable par programmation. Tenez-en compte si votre produit revendique une provenance vérifiable.

Omni 1.1 Flash ou Veo 3.1 ?

Google propose désormais deux familles de génération vidéo accessibles avec la même clé API :

Veo 3.1 : rendu cinématographique avec génération audio native ;
Omni 1.1 Flash : modèle vidéo conversationnel conçu pour les interactions multi-tour et les modifications successives.

Une seconde de vidéo Omni en 720p coûte environ un quart du prix d’une seconde standard de Veo 3.1. Veo ne propose pas d’équivalent à la boucle d’édition multi-tour d’Omni.

La comparaison entre Gemini Omni 1.1 Flash et Veo 3.1 présente les cas d’utilisation adaptés à chaque modèle. Si vous utilisez déjà Veo, consultez le guide de l’API Veo 3.1 : cette version ne le déprécie pas.

Migrer depuis `gemini-omni-flash-preview`

Toute intégration utilisant gemini-omni-flash-preview cessera de fonctionner après le 30 septembre 2026. Dans la plupart des cas, la migration consiste à remplacer l’identifiant du modèle :

gemini-omni-flash-preview

par :

gemini-omni-1.1-flash

Vérifiez cependant les deux points suivants.

1. Résolution par défaut

Le 720p est désormais la résolution par défaut. Les options 360p et 4K sont nouvelles. Si votre application suppose une taille de sortie fixe, inspectez la réponse réelle avant de déployer.

2. Format de la réponse

Les vidéos de plus de 4 Mo sont renvoyées sous forme d’URI plutôt que dans un champ base64 intégré. Un gestionnaire qui ne lit que output_video.data peut donc sembler ne rien recevoir lorsque vous augmentez la résolution.

Pour comparer les deux versions :

enregistrez la requête dans un client API ;
placez l’identifiant du modèle dans une variable d’environnement ;
exécutez la même requête avec les deux modèles ;
comparez la résolution et le format de la réponse ;
basculez vers la version GA après validation.

Apidog facilite ce test : conservez une requête enregistrée, changez d’environnement et comparez les réponses. Le guide de l’API Gemini Omni 1.1 Flash décrit la procédure complète.

FAQ

Quel est l’identifiant de Gemini Omni 1.1 Flash ?

gemini-omni-1.1-flash. L’identifiant de préversion supprimé le 30 septembre 2026 est gemini-omni-flash-preview.

Quand Gemini Omni 1.1 Flash est-il sorti ?

Le 27 août 2026, en disponibilité générale. La préversion avait été lancée le 30 juin 2026.

Gemini Omni 1.1 Flash est-il gratuit ?

Non. Il n’existe pas de niveau gratuit pour Omni et chaque génération est facturée. Les modèles texte, comme Gemini 3.6 Flash, disposent toujours d’une voie gratuite dans AI Studio.

Quelle est la durée maximale d’une vidéo Gemini Omni ?

Un clip initial dure 10 secondes. L’extension ajoute des segments de 10 secondes, jusqu’à un total de 40 secondes.

Gemini Omni génère-t-il de l’audio ?

La documentation couvre la sortie vidéo et précise que l’audio des clips de référence est ignoré. Veo 3.1 est le modèle avec génération audio native. Si le son est essentiel, commencez par le guide de l’API Veo 3.1.

Puis-je modifier une vidéo filmée avec mon propre appareil ?

Oui, pour une vidéo d’entrée de 10 secondes maximum, hors Espace économique européen, Suisse et Royaume-Uni. Téléchargez la vidéo avec l’API Files et transmettez son URI au modèle.

Conclusion

Omni 1.1 Flash est la première version de la famille qui semble prête pour une intégration en production. L’extension de scène améliore la continuité, les images clés rendent les transitions plus prévisibles et le mode brouillon 360p rend les itérations abordables.

Configurez une requête enregistrée avec l’identifiant GA, testez chaque résolution utilisée par votre application et migrez avant la fin septembre. Téléchargez Apidog pour conserver cette vérification dans votre workflow.

Comment prolonger une vidéo jusqu'à 40 secondes avec Gemini Omni 1.1 Flash

Antoine Laurent — Fri, 28 Aug 2026 08:34:26 +0000

Gemini Omni 1.1 Flash génère des clips de 10 secondes. L’extension de scène permet d’aller plus loin : chaque appel ajoute 10 secondes, jusqu’à une durée cumulée maximale de 40 secondes.

Essayez Apidog aujourd’hui

Le mécanisme existait déjà dans le modèle d’aperçu, mais il exploitait seulement la dernière seconde de la séquence. Les couleurs restaient relativement cohérentes, mais les vêtements changeaient et les mouvements de caméra se réinitialisaient. La version GA du 27 août 2026 utilise désormais 10 secondes de contexte précédent, ce qui améliore la cohérence visuelle et l’adhésion narrative.

Ce guide montre comment appeler l’extension, quelles sont ses limites et comment éviter qu’une séquence de 40 secondes ne dérive au troisième segment.

Appeler une extension

L’extension utilise l’API Files : téléchargez le clip, puis fournissez son URI avec une invite décrivant la suite de la scène.

import base64
from google import genai

client = genai.Client()

video_file = client.files.upload(file="my_video.mp4")

interaction = client.interactions.create(
    model="gemini-omni-1.1-flash",
    input=[
        {"type": "document", "uri": video_file.uri},
        {"type": "text", "text": "Continue the scene."},
    ],
)

with open("extended.mp4", "wb") as f:
    f.write(base64.b64decode(interaction.output_video.data))

Le traitement du fichier est asynchrone. Attendez donc qu’il soit prêt avant de créer l’interaction :

import time

while video_file.state == "PROCESSING":
    time.sleep(10)
    video_file = client.files.get(name=video_file.name)

if video_file.state == "FAILED":
    raise ValueError(video_file.state)

Si la vidéo provient d’Omni dans la même session, utilisez plutôt l’ID de l’interaction précédente. Cette méthode coûte moins de jetons et conserve davantage de contexte :

res2 = client.interactions.create(
    model="gemini-omni-1.1-flash",
    previous_interaction_id=res1.id,
    input="The camera pulls back to reveal the whole street.",
)

Le tutoriel de l’API détaille les options de résolution et de livraison.

Ajouter un personnage à une extension

Vous pouvez joindre des médias de référence et les cibler dans l’invite. Les fichiers sont accessibles via des emplacements tels que <IMAGE_REF_0> :

video_file = client.files.upload(file="my_video.mp4")
character_img = client.files.upload(file="character.png")

interaction = client.interactions.create(
    model="gemini-omni-1.1-flash",
    input=[
        {"type": "document", "uri": video_file.uri},
        {"type": "document", "uri": character_img.uri},
        {"type": "text", "text": "Extend this video: have the character shown in <IMAGE_REF_0> enter the scene and wave."},
    ],
)

Les références vidéo sont également prises en charge, avec une limite de trois clips de trois secondes. Elles servent à transmettre le mouvement et l’apparence ; leur audio est ignoré.

Limites à prendre en compte

40 secondes maximum : une génération initiale de 10 secondes, suivie de trois extensions.
Ajout en fin de clip uniquement : impossible d’insérer une séquence au début ou au milieu. Si le segment deux est incorrect, il faut le régénérer ainsi que tous les segments suivants.
10 secondes pour une vidéo téléchargée : cette limite concerne l’entrée envoyée via l’API Files. Les chaînes utilisant previous_interaction_id ne sont pas concernées.
Pas de dialogue avec les téléchargements étendus : vous pouvez étendre silencieusement une vidéo téléchargée, mais pas ajouter de dialogue pendant cette extension.
Restrictions régionales : le téléchargement et l’édition vidéo ne sont pas disponibles dans l’EEE, en Suisse ni au Royaume-Uni. Les vidéos générées par le modèle restent extensibles dans ces régions avec previous_interaction_id.
Une seule vidéo d’entrée : le modèle ne raisonne pas sur plusieurs vidéos simultanément.

Prototyper l’arc complet avant le rendu final

Une séquence de 40 secondes en 720p coûte environ 4,06 $ en sortie vidéo. Si l’histoire dérive au troisième segment, vous devrez souvent régénérer les segments trois et quatre, avec le risque de modifier une partie qui fonctionnait déjà.

Commencez par un prototype en 360p. Cette résolution est générée jusqu’à 60 % plus rapidement et coûte environ un tiers du prix : les quatre segments reviennent alors à environ 1,35 $. Une fois l’arc validé, relancez-le en 720p ou dans une résolution supérieure. Consultez l’article sur les tarifs pour le détail du calcul.

Définissez la résolution dans le format de réponse :

interaction = client.interactions.create(
    model="gemini-omni-1.1-flash",
    input=[
        {"type": "document", "uri": video_file.uri},
        {"type": "text", "text": "Continue the scene."},
    ],
    response_format={"type": "video", "resolution": "360p"},
)

Écrire des invites cohérentes sur quatre segments

Décrire le changement

Le modèle dispose déjà de 10 secondes de contexte. Décrivez donc l’action suivante plutôt que toute la scène :

La caméra zoome sur la porte.

Une nouvelle description complète du décor pourrait pousser le modèle à réinterpréter ce qui est déjà à l’écran.

Limiter chaque segment à un mouvement

Une extension qui demande deux actions risque de les précipiter toutes les deux. Pour dix secondes, prévoyez une seule action principale.

Utiliser des ancres de continuité

Indiquez explicitement ce qui doit rester identique, par exemple :

« la même veste rouge » ;
« le même angle de caméra en plongée » ;
« le même éclairage ».

Ces ancres donnent au modèle des éléments stables à conserver au raccord.

Planifier dans l’ordre de lecture

L’extension ne fonctionne que vers l’avant. Organisez donc la séquence dans son ordre définitif : corriger le début après coup implique de régénérer tout ce qui suit.

Le guide d’invite de Veo présente des principes également utiles pour les modèles vidéo.

Tester chaque extension

Une chaîne de quatre appels crée quatre points de rupture possibles. Enregistrez chaque étape comme une requête distincte dans Apidog, et stockez l’URI du fichier ainsi que l’ID d’interaction dans des variables d’environnement. Vous pourrez ainsi rejouer un segment précis sans reconstruire toute la chaîne.

Vérifiez également la forme de la réponse : une extension haute résolution peut dépasser 4 Mo et remplacer une vidéo base64 inline par un URI. Prévoyez un délai d’attente supérieur à celui de la génération initiale, car le modèle doit d’abord lire les 10 secondes de contexte.

Téléchargez Apidog pour configurer ce harnais de test.

FAQ

Quelle est la durée maximale d’une vidéo Gemini Omni ?

40 secondes : une génération initiale de 10 secondes, puis trois extensions de 10 secondes.

Puis-je étendre une vidéo que j’ai filmée moi-même ?

Oui, jusqu’à 10 secondes d’entrée, hors EEE, Suisse et Royaume-Uni. Téléchargez-la avec l’API Files et transmettez son URI.

Puis-je ajouter une séquence au début d’un clip ?

Non. L’extension ajoute uniquement du contenu à la fin.

Pourquoi mon personnage change-t-il d’apparence entre les segments ?

L’invite redécrit peut-être la scène au lieu de décrire uniquement le changement, ou l’ancre de continuité est trop vague. Indiquez ce qui doit rester identique et utilisez éventuellement une image de personnage comme référence.

Chaque extension coûte-t-elle plus cher ?

Oui. Chaque appel facture ses 10 secondes de sortie vidéo ainsi que les jetons d’entrée correspondant au contexte lu.

Que faire si j’ai besoin de plus de 40 secondes ?

Veo 3.1 étend les vidéos par tranches de 7 secondes, jusqu’à 148 secondes, uniquement en 720p. Consultez la comparaison des modèles et le guide de l’API Veo.

L’extension de scène transforme Omni d’une démonstration en outil exploitable, à condition de planifier correctement. Découpez votre scénario en quatre actions, prototypez l’arc complet en 360p, limitez chaque invite à un mouvement et ne passez en 720p qu’une fois la séquence validée.

Comment utiliser Gemini Omni gratuitement (restrictions géographiques)

Antoine Laurent — Fri, 28 Aug 2026 08:29:10 +0000

Gemini Omni est-il gratuit ? Les vraies options en 2026

L'API Gemini Omni n'est pas gratuite. Il n'existe ni niveau gratuit, ni crédits d'essai, ni offre de loisir à débit limité. Chaque seconde de vidéo générée avec gemini-omni-1.1-flash est facturée dès la première requête, à environ 0,10 $ par seconde pour une sortie en 720p.

Essayez Apidog dès aujourd'hui

Cela rompt avec le modèle établi par le reste de la famille Gemini. La version GA propose notamment l'extension de scène sur 40 secondes, le contrôle des images clés et une ébauche économique en 360p. En revanche, aucune voie gratuite n'est disponible.

Les modèles de texte de Google proposent un niveau gratuit à débit limité via AI Studio. Beaucoup de développeurs supposent donc que la vidéo fonctionne de la même manière. Ce n'est pas le cas.

Il existe toutefois deux façons d'utiliser le modèle sans le payer, dont une sans carte bancaire. L'API n'en fait pas partie.

Voie gratuite 1 : YouTube Shorts et YouTube Create

C'est la véritable option gratuite. Lorsque Google a présenté Gemini Omni, l'entreprise a indiqué que le modèle était « déployé gratuitement pour les utilisateurs de YouTube Shorts et de l'application YouTube Create ».

Dans Shorts, Gemini Omni fonctionne via Remix :

Sélectionnez un Short éligible.
Décrivez la modification souhaitée, par exemple l'ajout de votre image ou d'une référence visuelle.
Générez une nouvelle version.

Aucun abonnement, paramètre de facturation ou clé API n'est nécessaire.

La principale limite est régionale. YouTube Create est une application mobile disponible dans un nombre limité de pays. Vérifiez sa disponibilité dans votre région avant de l'inclure dans votre workflow.

Il s'agit également d'une interface grand public : un clip à la fois, sans script, traitement par lots ni intégration dans un pipeline. C'est une bonne option pour tester le modèle, mais pas pour construire une fonctionnalité automatisée.

Voie gratuite 2 : l'offre étudiante

Google propose aux étudiants universitaires éligibles 12 mois d'un plan Google AI sans frais. En dehors des États-Unis, il s'agit de Google AI Plus ; aux États-Unis, de Google AI Pro. La description du plan mentionne directement l'accès à Gemini Omni.

Vérifiez les conditions avant de vous inscrire :

Vous devez avoir au moins 18 ans, être étudiant et résider dans un pays où l'offre est disponible.
Votre statut étudiant est vérifié via SheerID.
Une méthode de paiement valide est requise lors de l'inscription.
L'activation doit être effectuée avant le 31 décembre 2026.
L'offre est renouvelée automatiquement sous la forme d'un plan payant, sauf annulation préalable.

Le dernier point est essentiel : l'accès est gratuit pendant douze mois, mais votre carte est déjà enregistrée. Programmez un rappel pour le onzième mois.

Cette offre donne accès à Omni dans l'application Gemini et Google Flow, avec une interface plus complète que YouTube Remix. Elle ne donne toujours pas accès à l'API.

Qu'en est-il des crédits API gratuits ?

Plusieurs sites affirment le contraire, mais le niveau gratuit de l'API Gemini couvre uniquement les modèles de texte. Omni et Veo n'en font pas partie.

La page tarifaire n'indique aucun niveau gratuit pour Omni. Les niveaux à débit limité qui encadrent l'utilisation gratuite n'incluent pas les modèles de génération vidéo.

Pour utiliser Omni de manière programmatique, vous devez activer la facturation. Le guide de l'API détaille la configuration, mais votre première requête de test sera facturée.

Ce que les offres payantes apportent réellement

Pour un travail exploratoire, un abonnement peut coûter moins cher que l'API : vous payez un montant mensuel fixe plutôt qu'un tarif à la seconde.

Interface	Accès	Coût
YouTube Shorts Remix, YouTube Create	Gratuit	0 $
Application Gemini, Google Flow	Google AI Plus, Pro ou Ultra	Abonnement
API Gemini	Facturation activée, paiement par seconde	Environ 0,10 $/s en 720p

Google a modifié ses limites d'abonnement vers un modèle basé sur le calcul à l'I/O 2026. Votre quota se rafraîchit toutes les cinq heures jusqu'à atteindre un plafond hebdomadaire. Les abonnés Pro et Ultra peuvent acheter des crédits supplémentaires.

AI Ultra coûte 100 $ et 200 $ par mois selon le niveau. L'extension de scène dans l'application Gemini est réservée aux abonnés : le workflow de 40 secondes nécessite donc un plan.

Le choix dépend de votre objectif :

Explorer le modèle : utilisez un abonnement et travaillez dans l'interface utilisateur.
Construire un produit : activez la facturation et payez à la seconde pour automatiser les appels.

Utiliser l'API payante au coût minimum

Puisque l'API ne propose aucune voie gratuite, commencez par réduire le coût de vos essais.

1. Faites vos brouillons en 360p

Omni génère du 360p pour un tiers du coût du 720p et jusqu'à 60 % plus rapidement. Un clip de 10 secondes coûte ainsi environ 0,34 $ au lieu de 1,01 $.

Pendant la phase de test des prompts, chaque rendu est généralement jetable. Payer un tiers du prix pour ces essais est donc le levier le plus important. La ventilation des prix fournit le calcul détaillé.

2. Mettez les résultats en cache

Stockez chaque fichier généré avec le prompt et les paramètres utilisés. Régénérer un clip identique représente une dépense inutile à 0,10 $ la seconde.

3. Augmentez le délai d'attente avant de réessayer

La génération vidéo est lente. Un délai d'attente ne signifie pas nécessairement que la génération a échoué. Une boucle de retry déclenchée par un timeout peut vous faire payer deux fois le même clip.

4. Configurez une alerte de facturation

Définissez l'alerte avant votre première requête, et non après votre première mauvaise surprise.

Sauvegarder la requête dans Apidog aide notamment à éviter les retries involontaires : vous définissez explicitement le délai d'attente, validez le format de la réponse et exécutez l'appel à votre convenance. Conservez également la clé API dans une variable d'environnement.

Ce que l'accès gratuit ne permet pas

Les deux voies gratuites ont les mêmes limites :

Aucun accès API : les interfaces YouTube et les abonnements donnent accès à des produits distincts, avec une facturation distincte.
Aucune automatisation ni traitement par lots : vous générez un clip à la fois, manuellement.
Aucun contrôle complet des paramètres : la résolution, le rapport d'aspect et le format de livraison sont des paramètres côté API.
Un filigrane est toujours présent : chaque génération porte un filigrane SynthID, invisible pour les spectateurs mais détectable par programme.

L'accès gratuit suffit pour vérifier si le modèle répond à votre besoin. Pour lancer une fonctionnalité, prévoyez en revanche un budget à la seconde dès le début du projet.

FAQ

Gemini Omni est-il gratuit ?

Dans YouTube Shorts et l'application YouTube Create, oui. Dans l'application Gemini et Google Flow, un abonnement Google AI Plus, Pro ou Ultra est nécessaire. Via l'API, non : aucun niveau gratuit n'est disponible.

Pourquoi Gemini 3.6 Flash a-t-il un niveau gratuit mais pas Omni ?

La sortie vidéo est facturée 17,50 $ par million de tokens, et une seconde de vidéo 720p représente 5 792 de ces tokens. L'économie est donc très différente de celle d'une complétion de texte. La voie gratuite AI Studio de Google couvre uniquement les modèles de texte.

Puis-je obtenir des crédits API gratuits pour Omni ?

Non. Le niveau gratuit de l'API Gemini n'inclut pas les modèles de génération vidéo.

L'offre étudiante inclut-elle l'API ?

Non. Elle couvre l'accès au plan Google AI, notamment l'application Gemini et Flow. L'utilisation de l'API est facturée séparément.

Quelle est la façon la moins chère de générer de la vidéo via une API ?

Dans la gamme Google, Veo 3.1 Lite coûte 0,05 $ par seconde en 720p, soit moins qu'Omni, mais sans 4K ni édition conversationnelle. La comparaison des modèles détaille ce compromis.

Pour une génération vidéo gratuite plus largement, consultez les méthodes d'accès gratuit à Veo.

Existe-t-il un essai gratuit de l'API Gemini Omni ?

Non. Aucun crédit d'essai n'est proposé. La facturation doit être activée avant le premier appel.

Conclusion

Google propose Gemini Omni gratuitement sur YouTube, mais conserve une API strictement payante. Les voies gratuites conviennent donc à l'évaluation, pas à la construction d'un produit.

Testez le modèle dans Shorts, vérifiez qu'il répond à votre besoin, puis prévoyez un budget API adapté. Commencez en 360p, sauvegardez votre première requête avec un délai d'attente raisonnable et téléchargez Apidog pour suivre le coût de chaque appel avant de recevoir la facture.

Gemini Omni 1.1 Flash vs Veo 3.1 : Quelle API vidéo choisir ?

Antoine Laurent — Fri, 28 Aug 2026 08:06:29 +0000

Veo 3.1 ou Gemini Omni 1.1 Flash : quel modèle vidéo choisir ?

Google propose désormais deux modèles de vidéo générative sous la même clé API, mais ils répondent à des besoins différents. Veo 3.1 est le moteur de rendu cinématographique avec audio natif. Gemini Omni 1.1 Flash, généralement disponible depuis le 27 août 2026, est le modèle conversationnel que vous pouvez modifier au fil des échanges.

Essayez Apidog dès aujourd’hui

Le choix dépend principalement de trois critères : avez-vous besoin de son, souhaitez-vous modifier le clip après l’avoir généré, et quelle doit être la durée finale ? Voici comment chaque modèle se distingue.

Tableau comparatif

Critère	Gemini Omni 1.1 Flash	Veo 3.1
ID du modèle	`gemini-omni-1.1-flash`	`veo-3.1-generate-preview` — avec variantes fast et lite
Surface d’API	API Interactions (`/v1beta/interactions`)	`generateContent`, avec opération longue durée
Audio natif	Non	Oui, toujours activé
Durée de clip de base	10 secondes	4, 6 ou 8 secondes
Durée maximale via extension	40 secondes, par paliers de 10 secondes	148 secondes, par extensions de 7 secondes, jusqu’à 20 fois
Contexte lu lors de l’extension	Jusqu’à 10 secondes de séquences précédentes	Non spécifié
Édition conversationnelle	Oui, via `previous_interaction_id`	Non
Première et dernière image	Oui	Oui, via `lastFrame`
Médias de référence	Jusqu’à 3 clips vidéo de 3 secondes chacun	Jusqu’à 3 images de référence
Résolutions	360p, 720p, 1080p, 4K	720p, 1080p, 4K — 720p uniquement lors de l’extension
Rapports d’aspect	16:9, 9:16	16:9, 9:16
Coût par seconde en 720p	Environ 0,10 $	0,40 $ standard, 0,10 $ fast, 0,05 $ lite
Niveau gratuit	Non	Non
Filigrane	SynthID	SynthID

Choisissez Gemini Omni 1.1 Flash si…

Vous devez modifier le résultat après l’avoir vu

C’est la principale différence. Omni utilise l’API Interactions : vous générez un clip, le regardez, puis envoyez une requête de suivi pour le modifier.

res1 = client.interactions.create(
    model="gemini-omni-1.1-flash",
    input="A woman playing violin outdoors.",
)

res2 = client.interactions.create(
    model="gemini-omni-1.1-flash",
    previous_interaction_id=res1.id,
    input="Make the violin invisible.",
)

Vous n’avez pas besoin de re-télécharger la vidéo ni de décrire à nouveau toute la scène. Veo n’offre pas d’équivalent : chaque requête est une nouvelle génération. Pour modifier le résultat, il faut donc envoyer une nouvelle invite et relancer le processus.

Vous voulez produire des ébauches à moindre coût

En 360p, Omni génère des vidéos jusqu’à 60 % plus rapidement, pour un tiers du coût du 720p. Veo commence en 720p. Lorsque vous testez une invite pour la douzième fois, l’écart devient significatif. Consultez la répartition des prix pour les détails.

Vous fournissez des vidéos plutôt que des images fixes

Omni accepte jusqu’à trois clips de référence de trois secondes et mappe leur mouvement sur la nouvelle scène. Veo utilise des images de référence. Pour reproduire un mouvement ou maintenir un personnage cohérent entre plusieurs plans, les références vidéo d’Omni offrent donc davantage de contrôle.

Vous devez préserver la cohérence lors d’une extension

Omni analyse jusqu’à 10 secondes de séquences précédentes avant de poursuivre la vidéo, contre la seule dernière seconde utilisée par le modèle d’aperçu. Le guide d’extension de scène détaille ce fonctionnement.

Choisissez Veo 3.1 si…

Vous avez besoin d’audio

Veo génère l’audio nativement avec la vidéo. La documentation d’Omni couvre la sortie vidéo, mais ignore l’audio dans les clips de référence. Si votre livrable doit inclure du son, Veo est le choix évident. Consultez le guide de l’API Veo 3.1.

Vous avez besoin de plus de 40 secondes

Veo s’étend par tranches de 7 secondes, jusqu’à 20 fois, pour atteindre 148 secondes. Omni est limité à 40 secondes.

Attention : les vidéos étendues de Veo sont uniquement disponibles en 720p. Un clip long et un clip 4K constituent donc deux cas d’usage différents.

Vous cherchez le coût par seconde le plus bas

Veo 3.1 Lite coûte 0,05 $ par seconde en 720p, soit la moitié du tarif d’Omni. En contrepartie, il ne prend pas en charge la 4K. Pour les générations en volume et à faible enjeu, Lite est l’option la moins chère des deux familles.

Vous voulez générer un clip court

Veo propose des clips de 4 et 6 secondes, tandis qu’Omni génère des vidéos de 10 secondes. Pour une vidéo finale de 4 secondes, Veo ne facture que 4 secondes ; Omni en facture 10.

La décision en quatre lignes

Besoin de son ? Veo 3.1.
Besoin de plus de 40 secondes ? Veo 3.1.
Besoin de modifier le clip après génération ou de créer des brouillons économiques ? Gemini Omni 1.1 Flash.
Besoin du coût par seconde le plus bas, sans autre contrainte ? Veo 3.1 Lite.

De nombreux pipelines utilisent finalement les deux modèles : Omni pour explorer et verrouiller le plan de manière conversationnelle, puis Veo pour produire la version finale avec audio. Ils partagent une clé API, ce qui simplifie leur configuration.

Deux intégrations différentes

Quel que soit votre choix, les deux modèles utilisent des points d’accès structurellement différents.

Omni envoie une requête POST vers /v1beta/interactions, avec le modèle dans le corps de la requête. La vidéo est renvoyée directement en base64, sauf si le fichier dépasse 4 Mo ; dans ce cas, la réponse contient une URI.

Veo fonctionne comme une opération longue durée que vous devez interroger. Les fichiers générés restent sur les serveurs de Google pendant deux jours avant d’être supprimés.

Cette différence est importante si vous envisagez de changer de modèle. Le code d’un modèle ne fonctionnera pas avec l’autre en remplaçant simplement la chaîne du modèle. Votre couche d’abstraction doit gérer à la fois :

une opération nécessitant un polling ;
un corps de réponse pouvant contenir deux formats différents.

La présentation de l’API Omni explique comment gérer ces réponses.

Avant de les intégrer à votre application, définissez une requête enregistrée pour chaque modèle dans Apidog. Conservez la clé API dans une variable d’environnement, vérifiez la structure des réponses et augmentez les délais d’expiration bien au-delà des valeurs par défaut.

Pour comparer la qualité des sorties, vous pourrez ainsi exécuter la même invite avec les deux modèles en quelques clics, sans réécrire des commandes curl.

FAQ

Gemini Omni remplace-t-il Veo ?

Non. Google propose les deux modèles, et Veo 3.1 n’est pas obsolète. Ils génèrent tous deux des vidéos, mais pour des usages différents.

Lequel est le moins cher ?

En 720p, Omni — environ 0,10 $ par seconde — et Veo 3.1 Fast — 0,10 $ par seconde — sont équivalents.

Veo 3.1 Lite est moins cher, à 0,05 $ par seconde. Veo 3.1 Standard est le plus coûteux, à 0,40 $ par seconde.

Peuvent-ils générer des vidéos avec des dialogues ?

Veo génère de l’audio natif. La sortie vidéo d’Omni ne couvre pas la génération audio et ne peut pas ajouter de dialogue lors de l’extension d’une vidéo téléchargée.

Les deux modèles ajoutent-ils un filigrane ?

Oui. Ils appliquent tous deux SynthID, invisible pour les spectateurs mais détectable par programmation.

Qu’en est-il de Sora ou des autres API vidéo ?

Les fournisseurs proposent des compromis différents. OpenAI Sora 2 et Seedance 1.0 sont à examiner si vous évaluez des solutions en dehors de l’écosystème Google.

Avec quel modèle commencer ?

Pour prototyper sans audio, commencez avec Omni en 360p. C’est le moyen le moins cher de vérifier si la vidéo générée répond à votre besoin. Téléchargez Apidog et enregistrez votre première requête afin de rendre les comparaisons reproductibles.

En résumé : Veo rend, Omni converse. La documentation Google sur la génération vidéo couvre les deux. Choisissez donc le modèle en fonction de la tâche, et non de l’équipe qui l’a développé.

Gemini Omni 1.1 Flash prix : ce que coûte réellement une seconde de vidéo

Antoine Laurent — Fri, 28 Aug 2026 08:05:22 +0000

Le coût réel de la génération vidéo avec Gemini Omni 1.1 Flash

Une seconde de vidéo 720p avec Gemini Omni 1.1 Flash coûte environ 0,10 $. C'est le chiffre à utiliser pour planifier votre budget, tel qu'indiqué sur la page de tarification de Google. Il n'existe aucun niveau gratuit : le premier clip généré en suivant la documentation sera facturé.

Essayez Apidog dès aujourd’hui

Le modèle est facturé en jetons, et non à la durée. Comprendre ce mécanisme permet d'identifier immédiatement les leviers d'optimisation. Le plus efficace consiste à utiliser le 360p pour les brouillons : vos coûts d'itération diminuent des deux tiers.

La grille tarifaire

Élément	Prix
Entrée (texte, image, vidéo, audio)	1,50 $ par million de jetons
Sortie texte	9,00 $ par million de jetons
Sortie vidéo	17,50 $ par million de jetons
Niveau gratuit	Aucun

Ces tarifs concernent gemini-omni-1.1-flash, le modèle GA (Disponibilité Générale) publié le 27 août 2026, ainsi que le point d'accès gemini-omni-flash-preview, qui sera retiré. Consultez les fonctionnalités livrées avec la version GA.

Comment la sortie vidéo est convertie en jetons

Google facture la vidéo comme le texte : par jetons de sortie. Une seconde de vidéo 720p correspond à 5 792 jetons :

5,792 tokens x ($17.50 / 1,000,000) = $0.1014 per second

Un clip 720p de 10 secondes coûte donc environ 1,01 $. Une scène de 40 secondes créée avec quatre appels d'extension coûte environ 4,06 $, auxquels s'ajoutent les jetons d'entrée du contexte précédent relu à chaque étape.

L'entrée reste peu coûteuse. À 1,50 $ par million de jetons, les images de référence et les vidéos jointes pèsent peu face à la sortie. N'optimisez pas la longueur du [REDACTED PROMPT]

Le levier du 360p

Google génère les aperçus 360p pour un tiers du coût du 720p et jusqu'à 60 % plus rapidement. Un brouillon de 10 secondes revient ainsi à environ 0,34 $, contre 1,01 $ en 720p.

L'itération des prompts vidéo nécessite rarement une seule tentative. Une session réaliste peut demander douze essais avant d'obtenir une prise exploitable :

Flux de travail	12 brouillons	1 rendu final	Total
Tout en 720p	12,17 $	1,01 $	13,18 $
Brouillons en 360p, final en 720p	4,06 $	1,01 $	5,07 $

Vous obtenez le même résultat avec 62 % de dépenses en moins, et les brouillons sont plus rapides à générer. Définissez resolution sur 360p dans response_format pendant l'itération, puis passez à une résolution supérieure uniquement lorsque le prompt est validé. Consultez le guide de l'API pour la structure de la requête.

Les résolutions 1080p et 4K sont des suréchantillonnages des images générées, et non des rendus natifs. Elles coûtent donc plus cher que le 720p. Avant de budgétiser un pipeline 4K, vérifiez les tarifs actuels par seconde sur la page de tarification de Google, qui fait autorité.

Combien coûte l'extension d'une scène ?

L'extension est souvent responsable des dépassements de budget. Une vidéo de 40 secondes ne correspond pas à une seule requête : elle comprend une génération initiale et trois appels d'extension, chacun facturant ses propres 10 secondes de sortie ainsi que le contexte précédent.

En 720p, une scène complète de 40 secondes coûte environ 4,06 $. Si un segment s'écarte du scénario, il faut régénérer à partir de ce segment.

La méthode la plus économique est la suivante :

Ébauchez toute la scène en 360p, pour environ 1,35 $.
Vérifiez la continuité sur les quatre segments.
Relancez le rendu final en 720p.

Le guide d'extension de scène détaille les situations où les extensions échouent le plus souvent.

Comparaison avec Veo 3.1

Les deux modèles utilisent la même clé API Gemini, ce qui peut masquer leur différence de prix :

Modèle	720p par seconde	4K par seconde	Niveau gratuit
Gemini Omni 1.1 Flash	~0,10 $	Niveau d'upscale, voir la page de tarification	Non
Veo 3.1	0,40 $	0,60 $	Non
Veo 3.1 Fast	0,10 $	0,30 $	Non
Veo 3.1 Lite	0,05 $	Non disponible	Non

Veo 3.1 standard coûte environ quatre fois plus cher qu'Omni en 720p. Veo 3.1 Lite est moins cher qu'Omni, mais le prix par seconde ne suffit pas pour choisir :

Veo génère de l'audio natif et s'étend jusqu'à 148 secondes, par segments de 7 secondes.
Omni propose une boucle d'édition conversationnelle sans équivalent direct dans Veo.

La comparaison complète explique quel modèle choisir selon le cas d'usage. Si vous utilisez déjà Veo, ce guide d'intégration reste valable.

Trois erreurs qui font exploser les coûts

Rendre en pleine résolution pour vérifier une petite modification.

Utilisez le 360p pour confirmer qu'une modification du prompt fonctionne. Réservez le 720p au rendu livré.

Régénérer en production ce qui pourrait être mis en cache.

La sortie est suffisamment déterministe pour être réutilisée. Stockez chaque fichier et indexez-le à partir du prompt et des paramètres. Régénérer deux fois le même clip est une dépense inutile.

Réessayer automatiquement après un timeout.

Un timeout côté client ne signifie pas nécessairement que la génération a échoué. Votre logique de retry peut donc facturer deux fois un seul clip. Augmentez le délai d'attente et vérifiez l'état de l'interaction avant de relancer.

Testez ce comportement avant la mise en production. Enregistrez la requête dans Apidog avec un timeout réaliste, validez la structure de la réponse et exécutez-la volontairement. Configurez également une alerte de dépenses dans Google Cloud Billing.

Estimer une facture mensuelle

Commencez par le nombre de secondes finalisées, puis ajoutez le coût des brouillons :

monthly cost = finished_seconds x $0.10
             + draft_seconds x $0.034

Exemple : une équipe livre 5 minutes de vidéo 720p par mois avec un ratio brouillon/final de plus grande part de la facture, même à un tiers du prix, car ils sont dix fois plus nombreux que les livrables. Pour réduire ce montant, diminuez le nombre de tentatives par élément conservé grâce à de meilleurs prompts et au contrôle des keyframes. Réduire le coût du rendu final aura beaucoup moins d'impact.

FAQ

Gemini Omni 1.1 Flash est-il gratuit ?

Pas via l'API. Omni n'a aucun niveau gratuit, même s'il est disponible gratuitement sur YouTube Shorts et YouTube Create. Le résumé des accès gratuits présente ces options. Les modèles de texte Google, comme Gemini 3.6 Flash, offrent encore un accès gratuit limité en débit via AI Studio.

Combien coûte une vidéo de 10 secondes ?

Environ 1,01 $ en 720p et 0,34 $ en 360p.

Pourquoi la vidéo est-elle facturée en jetons ?

Google facture toutes les sorties de modèles en jetons pour garantir un modèle de facturation cohérent. En 720p, une seconde de vidéo équivaut à 5 792 jetons, facturés 17,50 $ par million de jetons de sortie vidéo.

Les images d'entrée et les clips de référence coûtent-ils plus cher ?

Ils sont facturés 1,50 $ par million de jetons d'entrée, ce qui reste minime face au coût de la sortie vidéo. Ce n'est pas le principal poste à optimiser.

Le 4K en vaut-il la peine ?

Uniquement pour les livrables finaux. Le 1080p et le 4K sont des suréchantillonnages : ils n'ajoutent pas de détails que le modèle n'a pas générés, tout en augmentant la taille des fichiers et le coût.

Une génération échouée est-elle toujours facturée ?

Une génération qui renvoie une vidéo est facturée. Les rejets du filtre de contenu et les erreurs sans sortie ne devraient pas l'être. Surveillez toutefois votre tableau de bord de facturation pendant la première semaine de chaque nouveau pipeline.

La maîtrise des coûts repose davantage sur la discipline que sur l'optimisation théorique : brouillons en basse résolution, cache agressif, timeouts contrôlés et une requête enregistrée par type de tâche. Vous pourrez ainsi détecter rapidement une modification du modèle ou du prix avant qu'elle ne se transforme en facture. Téléchargez Apidog pour valider vos requêtes avant de découvrir leur coût.

GLM-5.3-Flash Vision : Envoyer des images à un modèle à 1M de contexte

Antoine Laurent — Thu, 27 Aug 2026 03:37:50 +0000

GLM-5.3-Flash : vision native et contexte d’un million de tokens

La plupart des modèles de vision vous obligent à choisir entre image et texte. GLM-5.3-Flash accepte les images comme des blocs de contenu dans une fenêtre de contexte de 1 048 576 tokens, avec tout le texte dont vous avez besoin dans la même requête.

Essayez Apidog aujourd’hui

Cette combinaison — entrée d’image native et vaste contexte — permet des flux de travail qu’aucune de ces capacités ne rend possibles seule. Voici la charge utile à utiliser, les cas d’usage pertinents et les limites à prendre en compte.

Une vision native, pas un adaptateur

Les précédents modèles de vision de Z.ai étaient séparés : GLM-5V-Turbo et GLM-4.6V possédaient chacun leur identifiant et leur point d’accès. GLM-5.3, lui, achemine la vision via des adaptateurs.

GLM-5.3-Flash est le premier modèle GLM-5 dont les images sont une entrée de première classe, dans le même appel et le même contexte que le texte.

En pratique, vous disposez de :

un seul identifiant de modèle ;
une seule ligne de facturation ;
un seul ensemble de limites de débit ;
une seule fenêtre de contexte pour les images et le texte.

Pour les anciennes approches, consultez notre guide d’API GLM-5V-Turbo et notre guide GLM-4.6V.

Construire la charge utile

L’image est envoyée dans un bloc de contenu typé. content n’est donc plus une chaîne, mais un tableau :

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": [
                {"type": "text", "text": "What is wrong with this layout on mobile?"},
                {
                    "type": "image_url",
                    "image_url": {"url": "https://example.com/mobile-view.png"},
                },
            ],
        }
    ],
)

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

Pour une image locale ou privée, utilisez une URL de données base64 :

import base64
from pathlib import Path

def image_block(path: str) -> dict:
    data = base64.b64encode(Path(path).read_bytes()).decode("utf-8")
    suffix = Path(path).suffix.lstrip(".").replace("jpg", "jpeg")
    return {
        "type": "image_url",
        "image_url": {"url": f"data:image/{suffix};base64,{data}"},
    }

Chaque image doit être son propre bloc :

content = [
    {"type": "text", "text": "Image 1 is the design. Image 2 is what we built. List the differences."},
    image_block("design.png"),
    image_block("built.png"),
]

L’ordre est important : le modèle lit le tableau séquentiellement. Placez le contexte avant les images et identifiez explicitement chaque image lorsque vous en envoyez plusieurs.

La configuration initiale et l’authentification sont détaillées dans notre guide d’API.

Flux de travail utiles

Déboguer avec une capture d’écran

C’est le cas d’usage le plus évident, et celui mis en avant par Z.ai. Sa documentation décrit un modèle capable d’observer des interfaces, des rendus et des retours d’interaction — davantage un scénario d’agent de programmation qu’une simple description d’image.

Envoyez le rendu défectueux et le code source dans la même requête :

content = [
    {"type": "text", "text": "This component renders incorrectly below 400px. Here is the screenshot and the source."},
    image_block("bug-mobile.png"),
    {"type": "text", "text": f"```
{% endraw %}
jsx\n{component_source}\n
{% raw %}
```"},
]

Le modèle analyse le rendu réel au lieu de dépendre de la description d’un humain. Vous éliminez ainsi une étape coûteuse : traduire un problème visuel en mots.

Comparer des designs

Envoyez deux images et demandez une comparaison. En CI, un outil de différence détecte les pixels modifiés tandis que le modèle estime si le changement est significatif.

Utilisez cette sortie pour trier les régressions à faire vérifier par un humain, pas pour bloquer seul un déploiement. Une comparaison de captures d’écran reste un jugement, pas une preuve.

Vérifier un document par rapport à sa spécification

C’est ici que la fenêtre de contexte d’un million de tokens devient réellement utile. Placez une longue spécification sous forme de texte et l’artefact généré sous forme d’image :

content = [
    {"type": "text", "text": f"Specification:\n\n{spec_text}"},
    {"type": "text", "text": "Below is the generated report. Does it satisfy every requirement above? List gaps."},
    image_block("generated-report.png"),
]

Une spécification de 40 pages et une image peuvent tenir dans le même prompt. Ce flux n’est pas possible de la même façon avec un modèle limité à 128K tokens et doté d’une vision basée sur des adaptateurs.

Les notes de version de Z.ai citent également les documents bureautiques et la recherche financière parmi les scénarios visés par le comportement d’agent.

Extraire des graphiques et des tableaux de bord

Demandez une structure JSON et validez-la systématiquement :

content = [
    {"type": "text", "text": "Extract the series in this chart as JSON: [{label, values: [...]}]. Return only JSON."},
    image_block("quarterly.png"),
]

La validation par schéma détecte les erreurs de structure, mais pas les nombres plausibles et incorrects. Pour les données importantes, utilisez les données sources plutôt qu’une image du graphique.

Pour l’extraction documentaire spécialisée, un modèle dédié peut rester supérieur à un généraliste. Voir GLM-OCR pour la compréhension de documents.

Vidéo et fichiers

La documentation de Z.ai mentionne les entrées vidéo et fichier avec le même mécanisme de blocs de contenu.

Restez prudent : ces fonctions sont récentes, moins documentées et moins testées publiquement que l’entrée d’image. De plus, la capacité annoncée par le modèle n’est pas forcément disponible sur la passerelle utilisée.

Si la vidéo est essentielle à votre application, testez-la avec vos propres médias et votre propre fournisseur avant de concevoir votre architecture autour de cette fonction.

Limites et modes d’échec

La multimodalité native ne garantit pas des résultats fiables. Prévoyez au minimum ces quatre problèmes :

Chiffres incorrects dans les graphiques. Le modèle peut produire une réponse fluide et bien formatée tout en lisant mal une valeur. Un schéma valide ne garantit pas une valeur correcte. Utilisez les données sous-jacentes lorsque la précision compte.

Texte trop petit. Les interfaces denses, les tableaux basse résolution et le code compressé se dégradent rapidement. Rognez la région d’intérêt au lieu de réduire toute l’image.

Précision spatiale limitée. Le modèle décrit généralement bien une relation comme « le bouton chevauche le champ », mais mesure mal un écart précis comme « 12 pixels trop à gauche ».

Confusion entre les images. Avec plusieurs images, un détail peut être attribué au mauvais visuel. Ajoutez des libellés dans les blocs de texte et limitez le nombre d’images lorsque la précision est critique.

Ces limites ne sont pas propres à GLM-5.3-Flash. Elles sont communes aux modèles de langage visuel, et le score de 57 sur l’Indice d’Intelligence ne les élimine pas. Concevez vos flux pour qu’une erreur soit détectée avant de déclencher une action.

Coût

Les images consomment des tokens d’entrée et sont facturées comme tels. Il n’existe pas de supplément séparé pour les images.

Au tarif catalogue, le coût est de 0,15 $ par million de tokens d’entrée, ou 0,075 $ pendant la promotion de lancement valable jusqu’au 9 septembre 2026.

Les images haute résolution peuvent consommer beaucoup de tokens. La résolution est donc un levier de coût important. Réduisez-la lorsque les détails fins ne sont pas nécessaires.

reasoning_effort vaut max par défaut et le raisonnement est facturé comme des tokens de sortie. Pour une extraction simple, low est souvent suffisant et nettement moins cher. Notre guide des prix détaille ces deux leviers.

Maîtriser le coût des images

Les images étant facturées comme des tokens d’entrée, l’optimisation de la résolution doit être arbitrée avec la précision attendue.

Appliquez cet ordre :

Rognez avant de réduire l’échelle. Envoyez la région pertinente en pleine résolution plutôt que tout l’écran à moitié réduit.
Adaptez la résolution à la question. Une réduction agressive peut convenir pour vérifier une mise en page, mais pas pour lire un message d’erreur.
Ne renvoyez pas les images inchangées. Dans une conversation multi-tours, une image déjà envoyée appartient au contexte. La rattacher à chaque tour la fait facturer à nouveau.
Définissez reasoning_effort explicitement. L’extraction simple nécessite rarement max.

L’objet usage de chaque réponse fournit le nombre réel de tokens consommés. C’est la seule façon de connaître le coût effectif d’une image au lieu de l’estimer à partir de sa taille de fichier.

Tester les appels multimodaux

Les tests manuels sont difficiles : une URL de données base64 produit des milliers de caractères et les réponses en texte libre masquent facilement les régressions.

Deux pratiques sont particulièrement utiles :

Conservez un petit jeu fixe d’images de référence et de réponses attendues.
Validez toute extraction structurée avec un schéma.

Apidog convient bien à ce workflow. Enregistrez les charges utiles d’image dans une requête, stockez la clé API dans une variable d’environnement et ajoutez des assertions au JSON produit par vos prompts.

Après un changement de modèle ou une mise à jour du fournisseur, relancez la suite pour vérifier que le comportement de vision reste stable.

FAQ

GLM-5.3 prend-il également en charge les images ?

Pas nativement. GLM-5.3 achemine la vision via des adaptateurs séparés. Flash est le modèle nativement multimodal. Voir notre comparaison.

Combien d’images peut-on envoyer par requête ?

Plusieurs, chacune dans son propre bloc image_url. La limite pratique dépend de votre budget de contexte.

Faut-il utiliser une URL ou du base64 ?

Les deux fonctionnent. Utilisez une URL publique pour une image déjà hébergée et accessible, et base64 pour une image locale ou privée.

La vidéo est-elle prise en charge ?

Z.ai documente l’entrée vidéo, mais cette fonction est récente et peu testée. Vérifiez-la avec vos propres médias et votre fournisseur.

Les images sont-elles facturées différemment ?

Non. Elles consomment des tokens d’entrée, la résolution influence donc directement le coût.

Prix GLM-5.3-Flash : Coût avant et après la promotion de lancement

Antoine Laurent — Thu, 27 Aug 2026 03:36:47 +0000

GLM-5.3-Flash est actuellement proposé à moitié prix. Cette offre se termine le 9 septembre 2026 : après cette date, toutes les projections fondées sur les tarifs actuels doubleront.

Essayez Apidog dès aujourd’hui

Voici ce que le modèle coûte maintenant, ce qu’il coûtera ensuite, comment il se compare aux alternatives et comment vérifier si l’écart compte pour votre charge de travail. Chiffres vérifiés le 27 août 2026 : les pages tarifaires pouvant changer, confirmez-les auprès de votre fournisseur avant de fixer un budget.

Tarifs

Type	Prix de lancement (jusqu’au 9 sept. 2026)	Prix catalogue (après)
Input	0,075 $ / 1 M de jetons	0,15 $ / 1 M de jetons
Output	0,25 $ / 1 M de jetons	0,50 $ / 1 M de jetons
Input mis en cache	0,015 $ / 1 M de jetons	0,03 $ / 1 M de jetons

Artificial Analysis publie un tarif combiné de 0,10 $ par million de jetons, calculé avec un ratio cache/entrée/sortie de 7:2:1. Ce chiffre facilite les comparaisons, mais votre ratio réel détermine votre facture.

Coût de trois charges de travail

Les exemples suivants utilisent le prix catalogue, le plus pertinent pour planifier les coûts après le 9 septembre.

Classificateur de support

Pour 100 000 tickets par mois, avec environ 800 jetons d’entrée et 100 jetons de sortie par ticket :

80 millions de jetons d’entrée : 12 $
10 millions de jetons de sortie : 5 $
Total : 17 $ par mois

Pour ce type de tâche, définissez reasoning_effort sur low : la quantité de sortie, et donc son coût, peut encore diminuer.

Assistant de codage

Pour 500 sessions par jour, avec 15 000 jetons d’entrée — dont une grande partie de contexte de fichiers répété — et 2 000 jetons de sortie par session :

225 millions de jetons d’entrée : 33,75 $
30 millions de jetons de sortie : 15 $
Sans cache : 48,75 $ par mois

Si 70 % des entrées sont mises en cache, le coût d’entrée descend à environ 14,85 $, pour un total d’environ 30 $ par mois.

Pipeline documentaire avec images

Pour 10 000 documents par mois, avec environ 40 000 jetons d’entrée — images comprises — et 1 500 jetons de sortie par document :

400 millions de jetons d’entrée : 60 $
15 millions de jetons de sortie : 7,50 $
Total : 67,50 $ par mois

Aucun de ces montants n’est élevé. C’est précisément l’intérêt de GLM-5.3-Flash.

Le cache est votre principal levier

À 0,03 $ par million contre 0,15 $ pour une nouvelle entrée, un jeton mis en cache coûte cinq fois moins cher.

Les charges de travail comportant un préfixe stable — invite système, document interrogé à plusieurs reprises ou base de code — doivent conserver ce préfixe identique d’un appel à l’autre.

L’erreur la plus fréquente consiste à placer une valeur variable au début de l’invite. Un horodatage, un identifiant de requête ou un nom d’utilisateur dans l’invite système invalide tout ce qui suit. Placez donc le contenu stable en premier et le contenu variable en dernier.

Z.ai a également indiqué que le stockage des entrées mises en cache était gratuit pour une durée limitée. Considérez cette mesure comme promotionnelle et vérifiez les conditions actuelles avant d’en dépendre architecturalement.

Réduisez l’effort de raisonnement

Sur ce modèle, reasoning_effort vaut par défaut max. C’est le réglage le plus coûteux.

Les trois modes disponibles sont low, high et max. Les jetons de raisonnement sont facturés comme des jetons de sortie. Une tâche de classification, d’extraction, de routage ou de formatage peut donc payer pour une réflexion qui n’apparaît jamais dans la réponse finale.

Pour ces tâches, commencez par low. La configuration est détaillée dans notre guide API. Il s’agit d’un changement d’une seule ligne et du premier réglage à vérifier si votre facture dépasse vos estimations.

Comparaison avec les autres modèles

Par rapport à son propre frère, au prix catalogue :

Modèle	Tarif combiné par million
GLM-5.3-Flash	0,10 $
GLM-5.3	0,90 $

L’écart est d’environ neuf fois pour seulement trois points de différence sur l’indice d’intelligence d’Artificial Analysis : 57 contre 60.

Notre comparaison complète détaille les cas où ce compromis devient défavorable. En bref : si vous diffusez de longues réponses à une personne en attente, GLM-5.3 peut être préférable, car il génère presque deux fois plus vite.

Par rapport à GLM-5.2, Z.ai annonce un prix environ dix fois inférieur, avec un coût par tâche de 0,045 $. Notre analyse des tarifs de GLM-5.2 reprend l’ancienne grille pour planifier une migration.

Face aux gammes multimodales économiques d’autres fournisseurs, GLM-5.3-Flash est compétitif et se distingue par sa licence MIT, qui laisse ouverte l’option de l’auto-hébergement. Notre article sur la tarification de Gemini 3.7 Flash couvre la comparaison la plus proche chez Google.

Les revendeurs appliquent leurs propres tarifs

Le modèle est disponible directement via Z.ai, mais aussi sur OpenRouter, Cloudflare Workers AI, Vercel AI Gateway, DeepInfra, Novita, GMICloud, Baseten et io.net.

Les tarifs peuvent varier fortement. AIHubMix, par exemple, a affiché environ 0,113 $ en entrée et 0,394 $ en sortie : des prix situés entre les tarifs promotionnels et catalogue de Z.ai. Certains fournisseurs répercutent la remise de lancement, d’autres non.

Si vous utilisez un agrégateur, vérifiez son tarif actuel au lieu de supposer qu’il correspond à celui de Z.ai. Une passerelle unifiée peut appliquer une marge, même si celle-ci reste facile à négliger à ces niveaux de prix.

À partir de quel volume l’auto-hébergement devient-il rentable ?

Les poids sont sous licence MIT, donc l’exécution locale est possible. Toutefois, la forte baisse du prix API rend le seuil de rentabilité plus difficile à atteindre.

À titre indicatif, un service en pleine précision nécessite un nœud de classe H200 avec huit GPU, facturé entre 24 $ et 48 $ par jour dans le cloud. En prenant un coût fixe de 1 000 $ par mois, que le nœud soit actif ou non :

1 000 $ au prix catalogue achètent environ 6,7 milliards de jetons d’entrée ;
il faut donc un volume très élevé et régulier pour amortir le nœud.

Pour la plupart des équipes, l’auto-hébergement de GLM-5.3-Flash se justifie davantage par le contrôle, la résidence des données ou la licence que par le prix.

L’équation change avec une version quantifiée. Des quantifications GGUF existent, et l’exécution sur du matériel déjà disponible réduit le coût marginal à celui de l’électricité. Notre guide d’exécution locale explique les capacités de chaque niveau matériel.

Le forfait de codage peut coûter moins cher

Si vous êtes une personne qui code dans Claude Code ou Cline plutôt qu’une application qui effectue des appels API, la facturation au jeton n’est peut-être pas le bon modèle.

Le forfait de codage GLM commence autour de 18 $ par mois, inclut GLM-5.3-Flash et fournirait apparemment trois fois le quota utilisable de GLM-5.3. La documentation de Z.ai indique aussi que les appels effectués en heures creuses consomment la moitié des points standards.

Pour une personne qui code quotidiennement, un forfait fixe est généralement moins cher et plus prévisible qu’un accès API à la consommation. Notre guide de configuration du harnais explique la mise en place. Notre comparaison des forfaits de codage met le forfait GLM face aux alternatives.

Surveillez surtout les sorties

L’entrée attire l’attention parce qu’elle représente souvent le plus gros volume. Pourtant, les budgets dérapent généralement côté sortie :

La sortie coûte plus de trois fois l’entrée par jeton : 0,50 $ contre 0,15 $.
Les jetons de raisonnement sont facturés comme des sorties.
Avec reasoning_effort réglé sur max, le modèle peut générer plusieurs fois plus de jetons que la réponse finale visible.

Une application avec une invite courte mais des réponses longues peut donc être dominée par les sorties, même si elle semble orientée vers l’entrée. Le tarif combiné de 0,10 $ suppose un ratio 7:2:1 que de nombreuses charges réelles ne respectent pas.

Mesurez au lieu d’estimer. Chaque réponse de complétion contient un objet usage indiquant les jetons consommés pour l’appel. Enregistrez ces valeurs, agrégerez-les et comparez le ratio réel avec votre hypothèse budgétaire.

Si les sorties dépassent environ 15 % du total des jetons, vérifiez d’abord reasoning_effort, puis la longueur des invites.

À faire avant le 9 septembre

Pendant la période de remise :

Mesurez votre répartition réelle. Le tarif combiné repose sur un ratio 7:2:1. Si vos sorties sont nombreuses, votre coût effectif se rapprochera davantage de 0,50 $ que de 0,10 $ par million.
Contrôlez le taux d’accès au cache. Avec un écart de prix de cinq fois entre une entrée mise en cache et une nouvelle entrée, c’est votre principal levier.
Recalculez au prix catalogue. Tout double le 10 septembre. Si votre charge de travail n’est rentable qu’au tarif promotionnel, corrigez-la maintenant.

Pour suivre l’utilisation réelle, capturez les réponses de complétion : l’objet usage contient les comptes d’entrée, de sortie et de cache nécessaires. Exécutez vos appels représentatifs comme une collection enregistrée dans Apidog, avec l’identifiant du modèle comme variable d’environnement. Vous pourrez comparer les factures par requête et rejouer la même suite contre GLM-5.3 plutôt que de vous fier au marketing.

FAQ

GLM-5.3-Flash est-il gratuit ?

Non. Il a été gratuit pendant environ une semaine lorsqu’il fonctionnait anonymement sous le nom « ox-alpha », avant son lancement. La remise actuelle de 50 % ne signifie pas qu’il est gratuit.

Quand la remise se termine-t-elle exactement ?

Le 9 septembre 2026. Le prix catalogue s’applique à partir de cette date.

Pourquoi les prix diffèrent-ils selon les sites ?

Certains affichent le tarif promotionnel, d’autres le prix catalogue, et les revendeurs ajoutent leur propre marge. Vérifiez toujours le fournisseur que vous appelez réellement.

Les images coûtent-elles plus cher ?

Les images consomment des jetons de contexte et sont facturées comme des entrées. Il n’existe pas de supplément image séparé, mais une image haute résolution peut consommer beaucoup de jetons.

L’auto-hébergement est-il moins cher ?

Seulement à très grand volume régulier, ou sur du matériel que vous possédez déjà avec une version quantifiée. À 0,15 $ par million de jetons d’entrée, louer un nœud H200 à huit GPU est difficile à justifier uniquement par le coût.

GLM-5.3-Flash vs GLM-5.3 : Lequel choisir ?

Antoine Laurent — Thu, 27 Aug 2026 03:34:49 +0000

Z.ai propose désormais deux modèles aux noms presque identiques, avec une fenêtre contextuelle de 1 million de jetons, mais un écart de prix pouvant atteindre neuf fois. Ne vous fiez pas au nom : GLM-5.3-Flash est moins cher, prend en charge les images nativement et offre un quota de codage 3× supérieur ; GLM-5.3 est légèrement plus intelligent et génère presque deux fois plus vite.

Essayez Apidog dès aujourd’hui

Pour la plupart des charges, Flash est le bon choix par défaut. Voici quand choisir l’autre modèle.

Comparatif rapide

	GLM-5.3-Flash	GLM-5.3
Indice d’intelligence (Analyse Artificielle)	57	60
Prix moyen par million de jetons	0,10 $	0,90 $
Prix catalogue entrée / sortie par million	0,15 $ / 0,50 $	1,40 $ / 4,40 $
Vitesse de sortie	~49 jetons/s	~86 jetons/s
Temps au premier jeton	1,52 s	1,57 s
Fenêtre contextuelle	1 048 576 jetons	1 048 576 jetons
Entrée d’image native	Oui	Non, via adaptateur
Paramètres	320 Md au total / 18 Md actifs	Plus grand, non entièrement divulgué
Licence	MIT, poids ouverts	Poids ouverts
Quota du plan de codage	3×	1×

Les mesures de vitesse et d’intelligence proviennent d’Analyse Artificielle. Les tarifs sont ceux de Z.ai, hors réduction de lancement.

Pourquoi Flash coûte neuf fois moins cher

GLM-5.3-Flash est un modèle MoE de 320 milliards de paramètres qui en active 18 milliards par jeton. Son architecture hybride combine attention linéaire et clairsemée.

Selon Z.ai, Flash demande environ trois fois moins de calcul d’attention que GLM-5.3 et utilise un cache KV environ 4,4 fois plus petit. C’est déterminant pour les contextes longs : un cache KV plus compact réduit directement le coût de service d’une requête à 1 million de jetons.

Vous ne payez donc pas moins pour une fenêtre plus petite, mais pour une empreinte d’inférence réellement plus faible.

Trois points d’intelligence : quand est-ce important ?

L’écart entre 57 et 60 reste faible. Les deux modèles se situent très au-dessus du modèle à poids ouverts médian de taille comparable, évalué à 27.

En pratique, les trois points d’écart apparaissent surtout sur :

le raisonnement multi-étapes ;
les agents exécutant de longues chaînes d’actions ;
les instructions ambiguës ou sous-spécifiées.

Ils sont rarement visibles sur l’extraction, la classification, le résumé, le routage ou l’édition d’un seul fichier.

La règle pratique est simple :

Sortie vérifiable par programme : choisissez Flash. Vous pouvez détecter un échec, relancer et rester très loin sous le coût de GLM-5.3.
Sortie évaluée par une personne : GLM-5.3 peut justifier son coût si une légère amélioration de qualité compte davantage que le prix.

Flash n’est pas le plus rapide

C’est le point contre-intuitif : GLM-5.3 génère environ 86 jetons/s, contre 49 jetons/s pour Flash. Le modèle plus cher produit donc les longues réponses presque deux fois plus vite.

Le temps au premier jeton est quasiment identique :

Flash : 1,52 s ;
GLM-5.3 : 1,57 s.

Conséquences :

Réponses courtes : la différence est négligeable.
Réponses de 4 000 jetons : comptez environ 82 secondes avec Flash contre 47 secondes avec GLM-5.3.
Traitements batch parallèles : Flash reste souvent préférable, car son coût permet davantage de concurrence.

Si vous diffusez une réponse longue à une personne qui attend, GLM-5.3 offre la meilleure expérience.

La multimodalité est le principal facteur de choix

GLM-5.3-Flash accepte nativement images, vidéos et fichiers dans une requête de chat avec du texte. GLM-5.3 s’appuie sur des adaptateurs de vision séparés.

Si votre application doit analyser une interface, une capture d’écran, un document ou un fichier avec son contexte textuel, Flash est le seul choix des deux qui réunit tout dans :

un appel ;
une fenêtre contextuelle ;
une ligne de facturation.

Cette capacité est particulièrement utile avec 1 million de jetons de contexte : vous pouvez fournir une longue spécification et une capture du résultat construit dans la même invite.

Consultez notre guide de vision pour la charge utile et les flux de travail, ou le guide API de GLM-5V-Turbo si vous maintenez une intégration plus ancienne.

Le cas des forfaits de codage

Pour les abonnés au plan de codage GLM, Flash offre trois fois plus de quota utilisable que GLM-5.3. Z.ai indique aussi que les appels hors pointe coûtent la moitié des points standards.

Pour Claude Code ou Cline, utilisez Flash pour le volume et réservez GLM-5.3 aux problèmes de raisonnement les plus difficiles. La configuration des deux environnements est détaillée dans notre guide Claude Code et Cline.

Vérifiez tout de même le multiplicateur actuel sur z.ai : les conditions des forfaits changent plus vite que les spécifications des modèles.

Réduction de lancement jusqu’au 9 septembre 2026

Une réduction de lancement de 50 % sur GLM-5.3-Flash est valide jusqu’au 9 septembre 2026.

Pendant cette période, les tarifs effectifs sont :

entrée : 0,075 $ par million de jetons ;
sortie : 0,25 $ par million de jetons.

L’écart avec GLM-5.3 atteint alors environ 18×. Après expiration, les tarifs catalogue de 0,15 $ en entrée et 0,50 $ en sortie ramènent l’écart à environ 9×.

La réduction influe sur vos projections de coût, mais pas vraiment sur le choix par défaut : Flash reste nettement moins cher. Retrouvez le détail dans notre analyse des prix.

Règle de décision

Utilisez GLM-5.3-Flash si :

vos entrées incluent des images, vidéos ou fichiers ;
vous optimisez le coût par jeton ;
vous traitez de gros volumes d’extraction, classification ou routage ;
vous souhaitez étendre votre quota de plan de codage ;
vous voulez des poids ouverts sous licence MIT à auto-héberger.

Pour l’exécution locale et le matériel requis, consultez ce guide.

Utilisez GLM-5.3 si :

vous affichez de longues réponses à une personne qui attend ;
votre charge repose sur un raisonnement long où de petites erreurs s’accumulent ;
la sortie est jugée par une personne plutôt que validée par un test.

Utilisez les deux si vous pouvez router

Envoyez la majorité du trafic vers Flash, puis escaladez vers GLM-5.3 lors d’un échec, d’une faible confiance ou pour certains types de tâche.

Les deux modèles utilisent le même point de terminaison compatible OpenAI : le routage consiste simplement à changer l’ID du modèle.

Migrer de GLM-5.3 vers Flash

La mécanique est simple ; la validation est l’étape importante.

Ne change pas :

URL de base ;
authentification ;
formats de requête et de réponse ;
streaming ;
appels d’outils.

Change :

coût par appel environ neuf fois inférieur ;
débit de génération environ deux fois plus faible ;
score de raisonnement inférieur de trois points ;
ajout de l’entrée d’image native.

Avant de basculer, exécutez vos invites réelles sur les deux modèles et comparez :

la justesse des sorties vérifiables ;
la latence de bout en bout, pas seulement le premier jeton ;
les jetons remontés dans l’objet usage ;
le comportement sur votre contexte réaliste le plus long.

Le dernier point est le plus important : deux modèles semblables sur des invites courtes peuvent diverger lorsque le contexte approche sa limite.

Pour partir des bases, consultez ce qu’est GLM-5.3 et le guide API GLM-5.3.

Testez avec vos propres invites

Les benchmarks sont utiles, mais ils ne remplacent pas vos données et vos contraintes. Pointez un client compatible OpenAI vers :

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

Puis exécutez les mêmes invites avec glm-5.3-flash et glm-5.3. Comparez sorties, latence et consommation de jetons sur votre trafic réel. Le guide API Flash fournit la configuration.

Dans Apidog, placez les deux appels dans une même collection, utilisez une variable d’environnement pour l’ID du modèle, ajoutez des assertions sur les champs exploités par votre application et relancez la comparaison lorsque les tarifs ou les modèles évoluent.

FAQ

GLM-5.3-Flash est-il simplement une version plus petite de GLM-5.3 ?

Non. C’est un modèle de base entraîné séparément, avec une architecture d’attention différente ; ce n’est ni une distillation ni une version élaguée.

Ont-ils la même fenêtre contextuelle ?

Oui : 1 048 576 jetons pour les deux.

Lequel est meilleur pour le codage ?

Selon Z.ai, Flash atteint 84,3 sur Terminal-Bench 2.1 et 63,4 sur DeepSWE. GLM-5.3 reste légèrement meilleur en raisonnement général. Pour les abonnés aux forfaits de codage, le quota 3× de Flash est généralement décisif.

Puis-je passer de l’un à l’autre sans modifier mon code ?

Oui. Ils utilisent le même point de terminaison compatible OpenAI ; seul l’ID du modèle change. L’entrée d’image reste exclusive à Flash.

Le modèle le moins cher restera-t-il moins cher ?

L’avantage tarifaire repose sur un cache KV plus petit et moins de calcul d’attention, pas uniquement sur une promotion. La réduction supplémentaire de 50 % expire toutefois le 9 septembre 2026.

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

Antoine Laurent — Thu, 27 Aug 2026 03:33:45 +0000

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 :

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}"},
   }

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}},
   ]

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.

Comment utiliser GLM-5.3-Flash dans Claude Code et Cline

Antoine Laurent — Thu, 27 Aug 2026 03:33:08 +0000

Si vous êtes déjà abonné au Plan de Codage GLM, GLM-5.3-Flash mérite votre attention pour une raison : il offrirait trois fois le quota utilisable de GLM-5.3 sur le même plan, contre un score de 57 sur l’Artificial Analysis Intelligence Index au lieu de 60.

Essayez Apidog dès aujourd’hui

Pour le codage quotidien, ce compromis est souvent avantageux. Voici comment configurer Flash dans Claude Code et Cline, éviter les erreurs courantes et réserver GLM-5.3 aux tâches les plus difficiles.

Prérequis

Un abonnement au Plan de Codage GLM de z.ai, à partir d’environ 18 $ par mois.
Une clé API depuis le tableau de bord Z.ai.
Claude Code ou Cline installé.

Vérifiez les quotas et les niveaux de plan directement sur z.ai avant de vous engager : les conditions évoluent régulièrement, et le multiplicateur 3x provient de la documentation de Z.ai.

Configurer Claude Code

Z.ai propose un point de terminaison compatible avec Anthropic. Dans Claude Code, il suffit donc de rediriger l’URL de base et le jeton.

Option rapide

L’assistant de Z.ai configure automatiquement votre environnement :

npx @z_ai/coding-helper

Saisissez votre clé API lorsqu’il vous la demande, puis sélectionnez glm-5.3-flash.

Option manuelle

Ajoutez ces variables à votre profil shell :

export ANTHROPIC_BASE_URL="https://api.z.ai/api/anthropic"
export ANTHROPIC_AUTH_TOKEN="your-z-ai-key"

Lancez ensuite Claude Code normalement : les requêtes seront envoyées à Z.ai.

Points à vérifier :

ANTHROPIC_API_KEY et ANTHROPIC_AUTH_TOKEN sont différents. Supprimez toute ancienne variable ANTHROPIC_API_KEY, car avoir les deux peut provoquer des erreurs d’authentification trompeuses.
Les variables doivent être visibles par le processus. Si vous lancez Claude Code depuis un IDE ou un lanceur, vérifiez qu’il charge votre profil shell. Testez dans le même contexte avec :

echo $ANTHROPIC_BASE_URL

Choisir le modèle

Si votre environnement utilise un fichier de configuration, définissez le modèle ainsi :

{
  "model": "glm-5.3-flash"
}

Pour les requêtes longues, augmentez le délai d’attente :

export API_TIMEOUT_MS=3000000

Une fenêtre de contexte de 1 million de jetons peut produire des requêtes légitimement longues. Cette valeur vient de la configuration GLM-5.2 ; adaptez-la selon votre usage. Consultez aussi notre guide d’intégration de GLM-5.2 si vous migrez une configuration existante.

Configurer Cline

Cline utilise son fournisseur compatible OpenAI :

Ouvrez les paramètres de Cline.
Choisissez Compatible OpenAI comme fournisseur d’API.
Définissez l’URL de base sur https://api.z.ai/api/coding/paas/v4.
Collez votre clé API Z.ai.
Sélectionnez Modèle personnalisé et entrez glm-5.3-flash.

Utilisez bien l’URL du Plan de Codage :

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

Elle est différente de l’URL API standard :

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

L’URL standard sert aux appels API directs, comme dans notre guide API. Utiliser cette URL avec une clé de Plan de Codage entraîne fréquemment des erreurs d’autorisation. Vérifiez toujours les chemins actuels dans la documentation de Z.ai.

Régler la fenêtre contextuelle

Cline n’infère pas toujours correctement la fenêtre contextuelle des modèles personnalisés. Pour les grandes bases de code, définissez-la manuellement sur 1 000 000.

Sans ce réglage, Cline peut supprimer des fichiers du contexte trop tôt, même si le modèle peut les conserver.

Pourquoi utiliser Flash pour le codage agentique ?

D’après les chiffres de lancement de Z.ai :

Benchmark	GLM-5.3-Flash	GLM-5.2
Terminal-Bench 2.1	84.3	non directement comparable
DeepSWE	63.4	46.2
AutomationBench	48.8	26.2

Le score Terminal-Bench a été évalué avec Claude Code 2.1.207, ce qui le rend pertinent pour cet environnement. Ces résultats restent toutefois des affirmations du fournisseur en l’absence de reproductions indépendantes.

Artificial Analysis attribue à Flash un Indice d’Intelligence de 57, contre 60 pour GLM-5.3.

Flash ajoute aussi une capacité utile pour le développement front-end : l’entrée d’image native. Vous pouvez fournir une capture d’écran d’une interface cassée avec votre code afin que le modèle analyse le rendu réel, plutôt qu’une simple description. Z.ai met en avant cette capacité d’observation des interfaces ; notre guide de vision explique cette intégration.

Le compromis : quota contre vitesse

GLM-5.3-Flash génère environ 49 jetons par seconde, contre environ 86 pour GLM-5.3.

Le temps jusqu’au premier jeton est presque identique — 1,52 contre 1,57 seconde — mais les longues sorties, comme une réécriture de fichier de 800 lignes, seront plus lentes avec Flash.

En pratique :

Utilisez Flash pour l’exploration, la lecture de code, les commandes, les petites modifications, les appels d’outils et les tâches liées aux images.
Passez à GLM-5.3 pour les problèmes d’architecture, les longues refactorisations ou après un premier échec de Flash.

Changer de modèle revient à modifier son identifiant dans la configuration. Cette stratégie conserve l’essentiel du volume sur le modèle à quota 3x et réserve le quota plus coûteux aux tâches qui le justifient.

Z.ai indique également que les appels hors pointe consomment la moitié des points standards. Planifier les tâches agentiques par lots ou en arrière-plan peut donc étendre davantage votre plan.

Dépannage

Erreurs 401 ou 403 sur toutes les requêtes. Vérifiez l’URL de base associée à votre type de clé et supprimez une éventuelle variable ANTHROPIC_API_KEY qui masquerait ANTHROPIC_AUTH_TOKEN.

Modèle introuvable. L’identifiant exact est glm-5.3-flash. Sur OpenRouter, il devient z-ai/glm-5.3-flash ; cet identifiant n’est pas interchangeable avec celui de Z.ai.

Contexte tronqué prématurément dans Cline. Réglez manuellement la fenêtre contextuelle sur 1000000.

Délais d’attente sur les requêtes importantes. Augmentez API_TIMEOUT_MS. Une requête avec un contexte réellement long peut dépasser les délais par défaut sans indiquer un problème côté service.

Quota épuisé trop vite. reasoning_effort utilise max par défaut et les jetons de raisonnement sont comptés. Si votre environnement le permet, utilisez low pour les tâches routinières.

Appels d’outils invalides ou échoués. Vérifiez que l’environnement et le point de terminaison utilisent le même format d’appel d’outil. C’est la partie la plus sensible aux mises à jour d’intégration.

Autres environnements

La même logique s’applique à la plupart des outils :

Les outils compatibles Anthropic — Claude Code et certains frameworks d’agents — utilisent https://api.z.ai/api/anthropic avec ANTHROPIC_AUTH_TOKEN.
Les outils compatibles OpenAI — Cline, Roo, Kilo, OpenCode, Codex et le modèle personnalisé de Cursor — utilisent https://api.z.ai/api/coding/paas/v4, votre clé API standard et glm-5.3-flash.

Pour les générations précédentes, consultez GLM-5.1 avec Claude Code et Claude Code et Cursor avec GLM-4.7.

Vérifier la connexion

Testez d’abord le point de terminaison directement :

curl https://api.z.ai/api/coding/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": "reply with OK"}]
  }'

Si cet appel renvoie une complétion mais que votre environnement échoue, le problème vient de la configuration locale, pas de vos identifiants.

Pour conserver et comparer ces requêtes, Apidog est plus pratique que l’historique du shell. Enregistrez les points de terminaison de codage et standard côte à côte, stockez la clé comme variable d’environnement et isolez rapidement un problème de point de terminaison d’un problème d’outil.

FAQ

Ai-je besoin d’un Plan de Codage ou les crédits API suffisent-ils ? Les deux fonctionnent. Le Plan de Codage est généralement plus économique pour un développement quotidien, tandis que l’accès API mesuré convient mieux aux applications. Notre article sur les tarifs les compare.

Flash offre-t-il vraiment 3x le quota de GLM-5.3 ? C’est le chiffre annoncé par Z.ai. Vérifiez-le sur z.ai/subscribe avant de planifier votre utilisation.

Pourquoi Cline tronque-t-il mon contexte ? Définissez manuellement la fenêtre contextuelle sur 1 000 000.

Quelle URL de base utiliser ? Utilisez https://api.z.ai/api/anthropic pour Claude Code, https://api.z.ai/api/coding/paas/v4 pour les outils compatibles OpenAI avec le Plan de Codage, et https://api.z.ai/api/paas/v4 pour les appels API directs.

Puis-je coller des captures d’écran dans Claude Code avec Flash ? Le modèle prend en charge l’entrée d’image native. Vérifiez toutefois que votre version de l’environnement expose cette capacité avant d’en dépendre.

Comment tester l'API GLM-5.3-Flash dans Apidog

Antoine Laurent — Thu, 27 Aug 2026 03:31:45 +0000

Tester GLM-5.3-Flash avec une collection Apidog réutilisable

Échanger un LLM dans votre application ne demande qu’une ligne de code, mais peut modifier fortement la latence, le coût des jetons, la stabilité du format de sortie, les appels d’outils et le traitement des images.

GLM-5.3-Flash illustre bien ces compromis : il coûte environ neuf fois moins cher que GLM-5.3, accepte nativement les images, mais génère environ deux fois moins vite. Pour savoir quel modèle convient à votre application, testez vos propres requêtes sur les deux.

Essayez Apidog dès aujourd’hui

Ce guide montre comment créer une collection de tests réutilisable pour l’API GLM-5.3-Flash dans Apidog : texte, images, appels d’outils, assertions et comparaison avec GLM-5.3.

Pourquoi ne pas utiliser uniquement curl ?

Vous pouvez tester ce point de terminaison avec curl ; notre guide d’API fournit un exemple complet. Mais deux problèmes apparaissent rapidement.

Les charges utiles d’images Base64 sont illisibles. Une capture d’écran encodée en URL de données peut contenir des milliers de caractères. Une commande collée dans le terminal devient difficile à lire, à modifier et à réexécuter.

Rien n’est vérifié automatiquement. Une réponse curl confirme seulement que l’appel a réussi. Elle ne garantit pas que les champs utilisés par votre application sont présents, ni que le modèle n’a pas tronqué sa réponse.

Une collection enregistrée règle ces deux problèmes : la charge utile reste modifiable et les assertions sont exécutées à chaque lancement.

Configurer l’environnement

Créez un environnement contenant les valeurs susceptibles de changer. Gardez surtout l’ID du modèle dans une variable afin de pouvoir rediriger toute la collection vers un autre modèle.

Variable	Valeur
`base_url`	`https://api.z.ai/api/paas/v4`
`api_key`	Votre clé Z.ai
`model`	`glm-5.3-flash`

Stockez la clé dans une variable d’environnement plutôt que directement dans les en-têtes de requête. Elle restera ainsi absente des collections exportées ou partagées.

Requête 1 : complétion de texte

Créez une requête POST vers {{base_url}}/chat/completions.

En-têtes :

Authorization: Bearer {{api_key}}
Content-Type: application/json

Corps :

{
  "model": "{{model}}",
  "messages": [
    {"role": "user", "content": "Reply with exactly: OK"}
  ],
  "reasoning_effort": "low"
}

reasoning_effort vaut max par défaut sur ce modèle. Le raisonnement étant facturé comme des jetons de sortie, utilisez low pour un simple test de connectivité.

Ajoutez les assertions suivantes :

Le code de statut est égal à 200.
choices[0].message.content existe.
choices[0].finish_reason est égal à stop.
usage.total_tokens existe.

L’assertion sur finish_reason est essentielle. Une valeur length indique que la réponse a atteint la limite de sortie au lieu d’être terminée. Comme la limite maximale annoncée pour ce modèle varie selon les sources, vérifiez explicitement ce cas.

Requête 2 : appel d’image

Cette requête vérifie la capacité native de traitement d’images de GLM-5.3-Flash, que GLM-5.3 ne possède pas.

Le point de terminaison reste identique, mais content devient un tableau de blocs typés :

{
  "model": "{{model}}",
  "messages": [
    {
      "role": "user",
      "content": [
        {"type": "text", "text": "Quelle est la couleur de la forme dominante dans cette image ? Répondez en un seul mot."},
        {"type": "image_url", "image_url": {"url": "{{test_image_url}}"}}
      ]
    }
  ],
  "reasoning_effort": "low"
}

Ajoutez test_image_url à l’environnement et faites-la pointer vers une image publique et stable dont vous connaissez la réponse. Une question déterministe sur une image fixe transforme cette démonstration en véritable test de régression.

Pour une image locale, le même champ accepte une URL de données Base64. Stockez-la comme variable d’environnement :

data:image/png;base64,iVBORw0KGgo...

Assertions recommandées :

Le code de statut est égal à 200.
choices[0].message.content contient la réponse attendue.
usage.prompt_tokens est supérieur à celui de la requête textuelle seule.

Les images consomment des jetons d’entrée. Si le nombre de jetons d’invite n’augmente pas, l’image n’a probablement pas été traitée, même si l’API renvoie 200.

Consultez notre guide de vision GLM-5.3-Flash pour les détails du chemin de vision et ses principaux modes de défaillance.

Requête 3 : appel d’outils

Si votre application utilise les appels de fonctions, testez-les séparément. Le format des appels d’outils est particulièrement sensible aux changements de version du modèle ou du fournisseur.

{
  "model": "{{model}}",
  "messages": [
    {"role": "user", "content": "Le service checkout-api est-il sain ?"}
  ],
  "tools": [
    {
      "type": "function",
      "function": {
        "name": "get_deployment_status",
        "description": "Renvoie le statut actuel d'un déploiement nommé.",
        "parameters": {
          "type": "object",
          "properties": {
            "service": {"type": "string", "description": "Le nom du service."}
          },
          "required": ["service"]
        }
      }
    }
  ]
}

Assertions :

choices[0].message.tool_calls existe et n’est pas vide.
choices[0].message.tool_calls[0].function.name est égal à get_deployment_status.
choices[0].finish_reason est égal à tool_calls.

Vérifier le nom de la fonction permet de détecter un modèle qui appelle le mauvais outil, et pas seulement l’absence totale d’appel.

Si vous générez les définitions depuis une API existante, notre guide sur la conversion d’une spécification OpenAPI en outils d’agent explique comment éviter de rédiger manuellement les schémas.

Comparer GLM-5.3 et GLM-5.3-Flash

Grâce à la variable model, la comparaison est rapide :

Dupliquez l’environnement.
Remplacez model par glm-5.3.
Exécutez la même collection.
Comparez les résultats.

Concentrez-vous sur trois critères :

Exactitude. Les assertions passent-elles toujours ? La requête d’image échouera avec GLM-5.3, qui ne prend pas les images en charge nativement. Il s’agit d’un résultat attendu, pas d’un test défectueux.
Latence. Apidog affiche le temps de réponse par requête. GLM-5.3 devrait terminer plus vite les sorties longues : environ 86 jetons par seconde contre 49 pour Flash.
Coût. L’objet usage fournit prompt_tokens et completion_tokens. Multipliez-les par le tarif de chaque modèle pour obtenir un coût réel par requête. Notre guide des tarifs présente les prix actuels, tandis que la comparaison complète des modèles détaille leurs points forts.

Surveillez aussi completion_tokens selon la valeur de reasoning_effort. Avec la valeur par défaut max, les jetons de raisonnement sont facturés comme des jetons de sortie. Une réponse visible très courte peut donc cacher un volume important de jetons. Exécutez la même invite avec low, high et max pour mesurer le besoin réel de votre charge de travail.

Tester un déploiement local

Si vous auto-hébergez les poids, vLLM et SGLang exposent tous deux des points de terminaison compatibles OpenAI. Remplacez base_url par l’URL de votre serveur et réutilisez la même collection.

C’est l’un des usages les plus utiles de cette suite. Une version quantifiée peut réussir un test de chat basique tout en échouant sur les schémas d’outils ou les entrées d’image — précisément les problèmes qui apparaissent en production.

Notre guide du déploiement local couvre la partie infrastructure.

Intégrer la collection dans la CI

Lorsque la collection est stable, exécutez-la selon un calendrier ou dans votre pipeline CI.

Déclencheurs utiles :

Avant une migration de modèle, comme signal de validation ou de blocage.
Selon un calendrier, pour détecter les changements côté fournisseur.
Après une mise à jour de dépendances, car un SDK peut modifier la sérialisation des requêtes.

Les fournisseurs peuvent mettre à jour un modèle derrière un ID qui reste identique. Une exécution planifiée révèle ces changements avant qu’ils ne soient signalés par un utilisateur.

Tester les cas limites

Après les scénarios de base, ajoutez :

Une requête avec la longueur de contexte réellement utilisée. Un comportement à 500 K jetons ne peut pas être déduit d’un test à 5 K.
Une entrée malformée pour exercer la gestion des erreurs.
Une réponse de limite de débit, si vous pouvez en provoquer une, afin de vérifier les réessais.
Plusieurs images dans une requête, si votre application le nécessite. Chaque image doit avoir son propre bloc image_url.
Le streaming, si vous l’utilisez, car sa réponse diffère d’une complétion standard.

Conclusion

La valeur ne réside pas dans chaque requête, mais dans leur répétabilité. Un choix de modèle que vous pouvez retester en trente secondes reste vérifiable lorsque les prix changent le 9 septembre, lorsque Z.ai publie une nouvelle révision ou lorsque vous envisagez un autre fournisseur.

Apidog est gratuit pour commencer. L’importation d’un schéma compatible OpenAI permet de générer une grande partie de cette configuration sans créer chaque requête manuellement.

La collection obtenue transforme le prochain changement de modèle en comparaison mesurable plutôt qu’en pari.

FAQ

Ai-je besoin d’un forfait Apidog payant ? Non. Les collections avec variables d’environnement et assertions fonctionnent avec le forfait gratuit.
Comment tester une image Base64 sans rendre le corps illisible ? Stockez l’URL de données dans une variable d’environnement et utilisez {{test_image_url}} dans le corps.
Puis-je tester le point de terminaison coding-plan de la même manière ? Oui. Remplacez base_url par https://api.z.ai/api/coding/paas/v4. Ce point de terminaison diffère de l’API standard, comme l’explique notre guide Claude Code et Cline.
Ces tests fonctionnent-ils avec d’autres fournisseurs ? En grande partie. OpenRouter, Cloudflare Workers AI et Vercel AI Gateway proposent des interfaces compatibles OpenAI. Il suffit de modifier base_url et l’espace de noms de l’ID du modèle.
Comment vérifier une réponse non déterministe ? Testez la structure et les contraintes plutôt que le texte exact : présence des champs, types, nombre de jetons, finish_reason et présence de sous-chaînes attendues.

Comment faire fonctionner GLM-5.3-Flash en local

Antoine Laurent — Thu, 27 Aug 2026 03:30:03 +0000

GLM-5.3-Flash est un modèle MIT de 320 milliards de paramètres. Il est donc libre à auto-héberger, mais exigeant en mémoire.

Essayez Apidog dès aujourd’hui

Ses 18 milliards de paramètres actifs par token et les versions quantifiées le rendent toutefois accessible au-delà d’un nœud 8x H200. Voici comment choisir votre matériel, votre runtime et vos paramètres.

Ce que vous chargez réellement

Propriété	Valeur
Paramètres totaux	320B
Actifs par token	18B
Architecture	MoE, attention hybride linéaire et sparse
Contexte	1 048 576 tokens
Licence	MIT
Poids	`zai-org/GLM-5.3-Flash`
Quantifications GGUF	`unsloth/GLM-5.3-Flash-GGUF`

L’architecture MoE réduit surtout le calcul : 18B de paramètres participent à chaque token. En revanche, les 320B de poids doivent résider en mémoire. Votre contrainte principale est donc la mémoire, pas les FLOPs.

Z.ai indique aussi un cache KV environ 4,4 fois plus petit que GLM-5.3. C’est important pour les longues fenêtres de contexte, où le cache KV devient généralement la principale source de consommation mémoire.

Niveau 1 : pleine précision en production

Pour servir le modèle à pleine qualité avec de la concurrence, prévoyez un nœud 8x H200 de 141 Go, soit environ 1 128 Go au total. Un nœud 8x H20 peut également convenir.

Les poids seuls demandent environ 700 à 800 Go selon la précision. Ajoutez une marge pour le cache KV et les frais d’exécution. En cloud, comptez approximativement 24 à 48 $ par jour.

Servir avec vLLM

vLLM est le choix le plus répandu. Utilisez une taille de parallélisation tensorielle puissance de deux :

vllm serve zai-org/GLM-5.3-Flash \
  --tensor-parallel-size 8 \
  --max-model-len 1048576 \
  --trust-remote-code

Commencez avec une valeur --max-model-len plus faible. Réserver immédiatement un million de tokens alloue le cache KV correspondant et peut provoquer une erreur mémoire qui masque un problème de configuration plus simple.

Servir avec SGLang

SGLang propose des recettes pour H100, H200, B200, B300 et GB200, y compris pour le service multimodal. Z.ai a utilisé une pile basée sur SGLang pour son service de pré-lancement.

python -m sglang.launch_server \
  --model-path zai-org/GLM-5.3-Flash \
  --tp 8 \
  --context-length 1048576

SGLang est souvent intéressant pour les sorties structurées et les charges agentiques très concurrentes. Pour un agent de code, mesurez vLLM et SGLang sur votre trafic réel plutôt que de choisir par défaut.

Dans les deux cas, configurez un analyseur d’appels d’outils pour activer correctement le function calling. Vérifiez les options de votre version : leurs noms évoluent entre les releases.

Niveau 2 : versions quantifiées sur matériel modeste

Les quantifications GGUF de unsloth/GLM-5.3-Flash-GGUF incluent des formats très agressifs, comme IQ1_S et IQ2_XXS. À 2 bits, les poids d’un modèle 320B peuvent tenir sur une station de travail riche en mémoire ou une machine multi-GPU grand public, en particulier avec déchargement CPU.

Gardez deux limites en tête :

La quantification agressive dégrade la qualité. IQ1_S est loin de la pleine précision. La dégradation peut être plus tolérable sur un MoE que sur un modèle dense, mais validez vos cas d’usage réels, notamment les outils et sorties structurées.
La documentation Unsloth est encore en cours de développement. Vérifiez les fichiers publiés et les réglages recommandés avant de concevoir votre déploiement autour d’un format précis.

Pour les machines hybrides CPU/GPU, KTransformers garde les experts MoE en RAM système et déplace vers le GPU uniquement ce qui est nécessaire. Avec seulement 18B de paramètres actifs par token, cette approche convient particulièrement bien à GLM-5.3-Flash. TokenSpeed figure également parmi les runtimes pris en charge.

Consultez aussi nos guides pour exécuter GLM-4.7-Flash localement et exécuter GLM-5 localement gratuitement.

Dimensionner votre budget mémoire

Basez votre capacité sur deux éléments.

Poids

En BF16, comptez environ 2 octets par paramètre :

320B en BF16 : environ 640 Go avant frais généraux ;
FP8 : environ la moitié ;
4 bits : environ 160 Go ;
2 bits : moins encore, avec une perte de qualité significative.

Cache KV

Le cache KV augmente avec la longueur de contexte et la concurrence. Une configuration stable à 8K peut échouer à 128K uniquement parce que le cache a grossi.

La réduction de 4,4x rapportée par Z.ai aide, mais la croissance reste linéaire en nombre de tokens. Dimensionnez donc le serveur pour votre contexte réel, pas pour le million de tokens annoncé si vous ne l’utilisez jamais.

L’article précédent sur l’auto-hébergement de GLM-5.3 précède la sortie de Flash. Les poids de GLM-5.3-Flash sont désormais disponibles sous licence MIT.

Réglage fin

La licence MIT autorise le réglage fin et la redistribution. C’est l’une des meilleures raisons de conserver les poids en interne.

Un fine-tuning complet de 320B est hors de portée de la plupart des équipes. Privilégiez LoRA ou d’autres méthodes efficaces en paramètres. Sur un MoE, déterminez également si vous adaptez le routeur, les experts ou les couches d’attention.

Avant d’entraîner le modèle, testez le prompting et la récupération de contexte. Avec une fenêtre d’un million de tokens, injecter les connaissances métier dans l’invite peut être moins coûteux et plus efficace qu’un entraînement.

Paramètres d’échantillonnage

Z.ai recommande les valeurs suivantes :

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

Le modèle propose aussi reasoning_effort avec low, high et max. max est la valeur par défaut.

En local, ce réglage influence directement le temps de génération. Si votre matériel est lent, utilisez low pour rendre les réponses exploitables.

L’auto-hébergement est-il rentable ?

Généralement, non : l’API reste souvent moins chère.

Au tarif catalogue, GLM-5.3-Flash coûte 0,15 $ par million de tokens d’entrée. Un nœud 8x H200 à environ 1 000 $ par mois équivaut à environ 6,7 milliards de tokens d’entrée via l’API. Sauf charge élevée et continue, le coût fixe du matériel loué est difficile à justifier.

Auto-hébergez plutôt pour :

la résidence des données et la confidentialité ;
l’absence de limites de débit externes ;
des garanties de disponibilité indépendantes d’un fournisseur ;
la possibilité de modifier, affiner et redistribuer les poids MIT ;
l’exploitation de GPU déjà achetés et inutilisés.

Notre analyse des prix détaille la comparaison côté API.

Vérifier le déploiement

vLLM et SGLang exposent des endpoints compatibles OpenAI. Testez votre serveur local avec une requête minimale :

curl http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "zai-org/GLM-5.3-Flash",
    "messages": [{"role": "user", "content": "reply with OK"}]
  }'

Ne vous limitez pas à ce smoke test. Validez :

le contexte long à la longueur réellement requise ;
les entrées image si vous servez la version multimodale ;
les appels d’outils avec vos schémas de production ;
le débit sous concurrence.

Configurez une collection de tests dans Apidog, puis exécutez-la contre votre serveur local et Z.ai en faisant de l’URL de base une variable d’environnement. Vous pourrez comparer les réponses et identifier rapidement les régressions de quantification, notamment sur les schémas d’outils.

FAQ

Quel est le matériel minimum ?

En pleine précision, un nœud de classe 8x H200. Les GGUF quantifiés demandent beaucoup moins, mais la qualité baisse avec le niveau de quantification.

Dois-je charger les 320B de paramètres en mémoire ?

Oui. Seuls 18B sont actifs par token, mais tous les poids doivent être présents en mémoire.

vLLM ou SGLang ?

SGLang a publié très tôt des recettes multimodales et excelle souvent avec la concurrence et les sorties structurées. vLLM bénéficie d’un écosystème plus large. Testez les deux sur votre charge réelle.

Puis-je l’exécuter sur un seul GPU ?

Pas en pleine précision. Avec une quantification agressive et le déchargement CPU via KTransformers, un GPU doté de beaucoup de VRAM accompagné de beaucoup de RAM système est plausible, mais lent.

La licence est-elle vraiment MIT ?

Oui. Elle permet l’usage commercial, la modification et la redistribution.

DEV Community: Antoine Laurent

Gemini Omni 1.1 Flash : les nouveautés du modèle vidéo GA de Google

Ce que fait Gemini Omni 1.1 Flash

Étendre une scène avec 10 secondes de contexte

Contrôler la première et la dernière image

Le mode brouillon 360p réduit le coût d’itération

Où utiliser Omni 1.1 Flash

Pas de niveau gratuit sur l’API

Limites à vérifier avant l’intégration

Omni 1.1 Flash ou Veo 3.1 ?

Migrer depuis gemini-omni-flash-preview

1. Résolution par défaut

2. Format de la réponse

FAQ

Quel est l’identifiant de Gemini Omni 1.1 Flash ?

Quand Gemini Omni 1.1 Flash est-il sorti ?

Gemini Omni 1.1 Flash est-il gratuit ?

Quelle est la durée maximale d’une vidéo Gemini Omni ?

Gemini Omni génère-t-il de l’audio ?

Puis-je modifier une vidéo filmée avec mon propre appareil ?

Conclusion

Comment prolonger une vidéo jusqu'à 40 secondes avec Gemini Omni 1.1 Flash

Appeler une extension

Ajouter un personnage à une extension

Limites à prendre en compte

Prototyper l’arc complet avant le rendu final

Écrire des invites cohérentes sur quatre segments

Décrire le changement

Limiter chaque segment à un mouvement

Utiliser des ancres de continuité

Planifier dans l’ordre de lecture

Tester chaque extension

FAQ

Comment utiliser Gemini Omni gratuitement (restrictions géographiques)

Gemini Omni est-il gratuit ? Les vraies options en 2026

Voie gratuite 1 : YouTube Shorts et YouTube Create

Voie gratuite 2 : l'offre étudiante

Qu'en est-il des crédits API gratuits ?

Ce que les offres payantes apportent réellement

Utiliser l'API payante au coût minimum

1. Faites vos brouillons en 360p

2. Mettez les résultats en cache

3. Augmentez le délai d'attente avant de réessayer

4. Configurez une alerte de facturation

Ce que l'accès gratuit ne permet pas

FAQ

Gemini Omni est-il gratuit ?

Pourquoi Gemini 3.6 Flash a-t-il un niveau gratuit mais pas Omni ?

Puis-je obtenir des crédits API gratuits pour Omni ?

L'offre étudiante inclut-elle l'API ?

Quelle est la façon la moins chère de générer de la vidéo via une API ?

Existe-t-il un essai gratuit de l'API Gemini Omni ?

Conclusion

Gemini Omni 1.1 Flash vs Veo 3.1 : Quelle API vidéo choisir ?

Veo 3.1 ou Gemini Omni 1.1 Flash : quel modèle vidéo choisir ?

Tableau comparatif

Choisissez Gemini Omni 1.1 Flash si…

Vous devez modifier le résultat après l’avoir vu

Vous voulez produire des ébauches à moindre coût

Vous fournissez des vidéos plutôt que des images fixes

Vous devez préserver la cohérence lors d’une extension

Choisissez Veo 3.1 si…

Vous avez besoin d’audio

Vous avez besoin de plus de 40 secondes

Vous cherchez le coût par seconde le plus bas

Vous voulez générer un clip court

La décision en quatre lignes

Deux intégrations différentes

FAQ

Gemini Omni remplace-t-il Veo ?

Lequel est le moins cher ?

Peuvent-ils générer des vidéos avec des dialogues ?

Les deux modèles ajoutent-ils un filigrane ?

Qu’en est-il de Sora ou des autres API vidéo ?

Avec quel modèle commencer ?

Gemini Omni 1.1 Flash prix : ce que coûte réellement une seconde de vidéo

Le coût réel de la génération vidéo avec Gemini Omni 1.1 Flash

La grille tarifaire

Comment la sortie vidéo est convertie en jetons

Le levier du 360p

Migrer depuis `gemini-omni-flash-preview`