Le 4 mai 2026, Google a officiellement annoncé sur son blog : Event-driven webhooks are now available in Gemini API. Deux jours plus tard, le 6 mai à 10h (heure de Pékin), cet e-mail en provenance de Google AI Studio a atterri dans les boîtes de réception des développeurs du monde entier, marquant le déploiement complet des webhooks de l'API Gemini pour tous les utilisateurs.
Pour de nombreuses équipes travaillant sur la recherche approfondie (Deep Research), la génération de vidéos longues ou l'inférence par lots (Batch) à grande échelle, il s'agit d'une mise à jour de niveau « infrastructure ». Ce n'est ni un nouveau modèle, ni de nouveaux paramètres, mais cela redéfinit complètement la manière d'interagir avec une tâche d'IA longue durée.
Cet article, basé sur les ressources officielles de Google et le Gemini Cookbook, décompose systématiquement les types d'événements des webhooks de l'API Gemini, les deux méthodes de configuration, le mécanisme de signature et de vérification, ainsi que le code pour bien démarrer. Nous discuterons également de ce que cela implique pour les développeurs.
Qu'est-ce que les webhooks de l'API Gemini : Comprendre les événements en une phrase
Les webhooks de l'API Gemini sont essentiellement un mécanisme de notification d'événements basé sur HTTP POST. Lorsque vos tâches par lots (Batch), vos tâches de génération vidéo ou vos interactions asynchrones sont terminées, l'API Gemini envoie activement une notification JSON signée à l'adresse de serveur que vous avez préalablement enregistrée, au lieu de vous obliger à interroger constamment l'état de la tâche via des requêtes GET.
Cette conception en « appel inversé » n'est pas nouvelle dans le développement logiciel traditionnel, mais elle prend tout son sens dans le contexte de l'inférence IA. Les services phares actuels de Gemini, comme le Deep Research, la génération de vidéos longues Veo et l'API Batch, ont des durées d'exécution allant de quelques minutes à plusieurs heures. Si l'on continuait à utiliser le polling (interrogation), le client devrait maintenir des connexions longues, des minuteurs et une logique de récupération d'erreurs, ce qui ferait exploser les coûts opérationnels et le gaspillage de quotas API.
🎯 À retenir : Webhooks de l'API Gemini = transformer le « Est-ce que c'est fini ? » répété par le client en une notification proactive du serveur. Le développeur n'a qu'à créer un point de terminaison de rappel et attendre la notification. Les équipes utilisant des services proxy API comme APIYI (apiyi.com) pour accéder à Gemini peuvent également tirer parti des notifications webhook pour réduire les requêtes de polling sur les liaisons internationales, réduisant ainsi considérablement la latence et la consommation de bande passante.
Notez que les webhooks de l'API Gemini envoient une « charge utile légère » (thin payload) : ils vous communiquent l'ID de la tâche, son état et le pointeur d'accès au fichier de résultat (par exemple output_file_uri), sans insérer directement des dizaines de Mo de vidéo ou des milliers de lignes de sortie batch dans le corps de la requête POST. Il s'agit d'une conception délibérée qui réduit les coûts de données lors des tentatives de nouvelle tentative et clarifie le contrôle des accès.
Pourquoi les webhooks de l'API Gemini marquent la fin de l'« ère du polling »
Pour comprendre la valeur des webhooks de l'API Gemini, il faut d'abord réaliser le coût du polling (interrogation). Avant l'arrivée des webhooks, un flux de tâches par lots (batch) typique ressemblait à ceci : soumettre la tâche → obtenir un ID d'opération → utiliser setInterval pour effectuer un GET toutes les 30 secondes → et ne pas pouvoir quitter le bureau avant que le statut ne passe à SUCCEEDED. Ce processus est acceptable pour une tâche isolée, mais il devient rapidement ingérable en environnement de production.
Le tableau ci-dessous compare le mode polling et le mode Webhook piloté par les événements sur plusieurs dimensions, soulignant les avantages de la migration mis en avant par Google dans son blog officiel.
| Dimension de comparaison | Mode Polling traditionnel | Webhook piloté par les événements (Gemini API) |
|---|---|---|
| Latence de notification | Dépend de l'intervalle (souvent 10-60 s) | Millisecondes (push immédiat à la fin) |
| Consommation de quota API | Chaque polling compte dans le quota de lecture | Le push est initié par Google, sans impact sur le quota |
| Complexité client | Nécessite timers, machines à états, retries | Un simple point de terminaison HTTP POST + vérification de signature |
| Concurrence massive | Tempête de requêtes pour des milliers de tâches | Push arrivant indépendamment, facile à scaler |
| Reprise après échec | À implémenter soi-même côté client | Retry automatique avec backoff exponentiel (jusqu'à 24h) |
| Scénarios adaptés | Tâches courtes, faible concurrence | Tâches longues, forte concurrence, pipelines d'agents |
Comme le montre ce tableau, les webhooks de l'API Gemini ne servent pas seulement à "économiser quelques lignes de code de polling" ; ils déplacent réellement la responsabilité de l'orchestration des tâches du client vers le serveur. Pour les équipes gérant des flux de travail d'agents, l'association des webhooks avec Cloud Run, Cloud Functions ou des services Serverless permet d'obtenir une architecture entièrement asynchrone, sans connexion persistante.
💡 Migration depuis le polling : Si votre code actuel repose sur des appels
GET /operations, la migration vers le mode webhook consiste simplement à remplacer la "boucle de polling" par une "route de rappel d'événement". La logique métier reste quasiment inchangée. Les équipes utilisant APIYI (apiyi.com) pour accéder à l'API Gemini peuvent connecter le point de terminaison du webhook directement à leur réseau interne, conservant ainsi les avantages du pilotage par événements tout en évitant l'instabilité des connexions longue distance.
Deux méthodes de configuration pour les webhooks de l'API Gemini : Statique vs Dynamique
L'API Gemini prend en charge deux méthodes d'enregistrement, répondant respectivement aux besoins de "notification globale" et de "routage par tâche". Comprendre la différence entre les deux est crucial pour votre stratégie de gestion des clés et de vérification des signatures.
Webhook statique : Abonnement aux événements globaux au niveau du projet
Le Webhook statique est enregistré une fois via l'API WebhookService et s'applique à tous les événements correspondants du projet. Il est idéal pour les scénarios de "diffusion systématique", comme le transfert de tous les événements batch.succeeded vers un canal Slack d'équipe, ou la synchronisation de tous les video.generated vers votre CMS ou stockage objet.
Concernant la signature, le Webhook statique utilise une clé symétrique HMAC. Google fournit une "signing secret" lors de la création, mais ne la renvoie qu'une seule fois. Vous devez impérativement la sauvegarder dans un service de gestion de clés, sinon vous devrez supprimer et recréer le webhook.
Webhook dynamique : Routage granulaire au niveau de la requête
Le Webhook dynamique offre une approche plus fine : vous spécifiez une URL temporaire dans le champ webhook_config à chaque soumission de tâche. Google enverra alors l'événement de cette tâche spécifique vers cette adresse. C'est particulièrement adapté aux scénarios SaaS multi-locataires, où les tâches de différents clients sont dirigées vers des points de terminaison distincts, garantissant une isolation claire.
Le Webhook dynamique permet également d'inclure un champ user_metadata (paires clé-valeur arbitraires, ex: {"job_group": "nightly-eval"}), que Google renverra tel quel lors de la notification. C'est une fonctionnalité très pratique qui vous évite de maintenir une table de correspondance externe entre les tâches et le contexte métier.
Pour la signature, le Webhook dynamique utilise une clé publique asynchrone JWKS (RS256). L'adresse de la clé publique est generativelanguage.googleapis.com/.well-known/jwks.json. Votre service récupère simplement la clé publique pour la vérification, sans avoir à gérer de clé symétrique.
| Dimension | Webhook statique | Webhook dynamique |
|---|---|---|
| Mode d'enregistrement | Enregistrement unique via WebhookService API | Spécifié dynamiquement à chaque requête |
| Portée | Projet entier | Tâche individuelle |
| Algorithme de signature | Clé symétrique HMAC | Clé publique JWKS / RS256 |
| Gestion des clés | Fournie une fois à la création | Aucune gestion, récupération via endpoint public |
| user_metadata | Non supporté | Supporte des métadonnées arbitraires |
| Scénarios typiques | Notifications globales, intégration Slack | Routage multi-locataires, distribution par tâche |
| Recommandé pour | Pipelines internes unifiés | Plateformes SaaS, services ouverts |
🎯 Conseil de sélection : Pour un traitement unifié au sein d'une équipe, privilégiez le Webhook statique. Pour une plateforme ouverte aux clients nécessitant un routage par locataire, optez pour le Webhook dynamique. Si vous utilisez APIYI (apiyi.com) pour relayer l'API Gemini, les deux modes sont nativement supportés, avec des en-têtes de signature et des payloads d'événements strictement identiques à l'original, sans barrière supplémentaire pour la migration.
Tutoriel : Webhooks de l'API Gemini en 5 lignes de code
Voici un exemple minimaliste pour vous lancer. De la création d'un webhook statique à la vérification de la signature, l'objectif est de mettre en place une boucle de rétroaction fonctionnelle en moins de 10 minutes.
Créer un webhook piloté par les événements de l'API Gemini avec le SDK Python
from google import genai
import os
client = genai.Client()
webhook = client.webhooks.create(
subscribed_events=["batch.succeeded", "video.generated"],
name="prod_global_notify",
uri="https://your-server.example.com/gemini/webhook",
)
# Le signing_secret n'est renvoyé qu'une seule fois, persistez-le immédiatement
os.environ["WEBHOOK_SIGNING_SECRET"] = webhook.new_signing_secret
Ce code effectue deux actions : il enregistre un point de terminaison global pour écouter les événements de réussite de traitement par lots (batch) et de génération de vidéo, puis stocke la clé de signature renvoyée par Google dans une variable d'environnement. En production, il est fortement recommandé de stocker ce secret dans un gestionnaire de secrets (Secret Manager, Vault, etc.) plutôt que de le laisser dans votre code source ou vos journaux.
Réception et vérification de la signature avec Node.js + Express
import express from "express";
import { Webhook } from "standardwebhooks";
const app = express();
const wh = new Webhook(process.env.WEBHOOK_SIGNING_SECRET);
app.post("/gemini/webhook", express.raw({ type: "*/*" }), (req, res) => {
try {
const event = wh.verify(req.body, req.headers);
console.log("événement :", event.type, "données :", event.data);
res.status(200).send("ok");
} catch (e) {
res.status(400).send("signature invalide");
}
});
app.listen(8080);
Quelques points cruciaux : utilisez impérativement express.raw pour récupérer le flux d'octets brut afin de vérifier la signature, sinon l'analyse JSON corrompra la signature. La réponse 2xx doit être envoyée en quelques secondes ; toute logique lourde (écriture en base de données, appels en aval) doit être traitée de manière asynchrone via une file d'attente. Il est également conseillé de rejeter les requêtes dont l'horodatage dépasse 5 minutes, conformément aux bonnes pratiques de défense contre le rejeu de Standard Webhooks.
🚀 Conseil pratique : Si votre service est déployé localement et que le point de terminaison doit être accessible par Google, exposez-le via un nœud à l'étranger ou un nœud de bordure CDN avant de rediriger vers votre réseau interne. Vous pouvez également utiliser un service proxy API comme APIYI (apiyi.com), qui prend en charge à la fois l'invocation du modèle Gemini et le relais des rappels (callbacks). Cela permet de recevoir les notifications webhook sur une couche intermédiaire avant de les transférer, simplifiant ainsi la gestion du NAT et du SSL.
Aperçu des types d'événements pris en charge par les webhooks de l'API Gemini
Actuellement, les webhooks de l'API Gemini couvrent principalement les changements d'état de trois grandes catégories de tâches longues. Le tableau ci-dessous répertorie les événements officiels.
| Groupe d'événements | Nom de l'événement | Déclencheur | Champs de payload clés |
|---|---|---|---|
| Batch API | batch.succeeded | Tâche traitée avec succès | id, output_file_uri |
| Batch API | batch.failed | Échec de la tâche | id, error |
| Batch API | batch.cancelled | Annulation par l'utilisateur | id |
| Batch API | batch.expired | TTL du batch dépassé | id |
| Video Generation | video.generated | Génération vidéo terminée | file_id, video_uri |
| Interactions API | interaction.requires_action | Action requise (outil) | id, required_action |
| Interactions API | interaction.completed | Dialogue asynchrone terminé | id, output |
| Interactions API | interaction.failed | Échec à n'importe quelle étape | id, error |
| Interactions API | interaction.cancelled | Annulation par l'utilisateur | id |
Chaque payload d'événement suit une structure unifiée : { "type": "batch.succeeded", "data": { "id": "...", "output_file_uri": "gs://..." } }. Cette forme "type + data" est idéale pour utiliser un routeur de type switch afin de diriger les événements vers les pipelines métier appropriés.
📌 Conseil d'architecture : Pour la mise en œuvre, il est recommandé d'utiliser un point de terminaison webhook combiné à un bus d'événements interne (Pub/Sub, Kafka, Redis Stream) plutôt que de créer un point de terminaison distinct pour chaque type d'événement. Cela respecte le modèle "réponse 2xx rapide + traitement asynchrone" recommandé par Google et facilite la montée en charge. Lorsque vous appelez l'API Gemini Batch et la génération vidéo Veo via APIYI (apiyi.com), les types d'événements sont identiques à ceux de l'API officielle, vous permettant de réutiliser directement votre logique de routage.
Mécanismes de sécurité et garanties de livraison des webhooks de l'API Gemini
La conception de sécurité des webhooks de l'API Gemini suit rigoureusement la spécification Standard Webhooks, un standard d'interopérabilité multiplateforme maintenu par la communauté. Cela signifie que si vous avez déjà intégré des webhooks pour des services comme Stripe, Svix ou Resend, vous pouvez quasiment réutiliser votre code sans modification.
Trois en-têtes HTTP essentiels
| En-tête de requête | Rôle | Utilisation recommandée |
|---|---|---|
| webhook-id | ID unique de l'événement | À utiliser comme clé d'idempotence pour éviter les traitements en double |
| webhook-timestamp | Horodatage de génération (secondes) | Rejeter les requêtes de plus de 5 minutes pour prévenir les attaques par rejeu |
| webhook-signature | Signature HMAC ou JWKS | Vérification en un clic avec la bibliothèque standardwebhooks |
Livraison "au moins une fois" et stratégie de réessai
Google garantit une livraison "au moins une fois" : votre point de terminaison recevra chaque événement au moins une fois, mais il est possible qu'il le reçoive plusieurs fois. Toute opération d'écriture en aval doit être conçue pour être idempotente ; la solution privilégiée consiste à utiliser le webhook-id comme clé unique lors de l'écriture dans votre base de données ou votre cache.
Si votre point de terminaison renvoie un code autre que 2xx, Google effectuera des réessais avec une stratégie de backoff exponentiel sur une fenêtre de 24 heures. Cela signifie que même en cas de panne temporaire de votre service, les événements ne seront pas perdus. Cependant, cela implique également que vous ne pouvez pas utiliser un "traitement synchrone bloquant" pour répondre : une réponse lente sera interprétée comme un échec.
Rotation de la clé de signature
La clé HMAC des webhooks statiques prend en charge le mode REVOKE_PREVIOUS_SECRETS_AFTER_H24, permettant de valider simultanément les anciennes et nouvelles clés pendant 24 heures. C'est crucial pour une transition en douceur en production : vous pouvez générer une nouvelle clé, la déployer sur tous vos nœuds, confirmer qu'ils l'acceptent tous, puis invalider l'ancienne clé pour finaliser la rotation sans interruption.
🔐 Conseil de sécurité : Tous vos points de terminaison de webhook doivent utiliser HTTPS, vérifier systématiquement la signature, limiter la taille du corps de la requête et mettre en place des disjoncteurs (circuit breakers) pour les appels lents. Si vous utilisez APIYI (apiyi.com) pour invoquer l'API Gemini ainsi que d'autres modèles, nous vous recommandons de centraliser tous vos points de terminaison de webhook vers un "passerelle d'événements" unique. Cela permet de gérer la vérification des signatures, la déduplication et le routage de manière centralisée, tout en facilitant l'audit de conformité et la gestion des clés.
Cas d'utilisation principaux des webhooks de l'API Gemini
Les webhooks de l'API Gemini ne sont pas destinés à tous les appels — la méthode generateContent, synchrone et à réponse milliseconde, n'en a pas besoin. Leur véritable valeur réside dans trois types de tâches longues, également soulignées par le blog officiel.
Agents asynchrones pour la recherche approfondie (Deep Research)
Les tâches de type Deep Research prennent souvent de quelques minutes à quelques heures, impliquant plusieurs étapes de recherche, d'appels d'outils et de synthèse. L'événement interaction.requires_action des webhooks s'adapte parfaitement à ces processus multi-tours. Vous pouvez recevoir un rappel à chaque nœud d'action et faire avancer le processus de manière asynchrone, plutôt que de maintenir un processus permanent pour suivre toute la session.
Inférence par lots (Batch API)
La Batch API est conçue pour les entrées contenant "des milliers, voire des centaines de milliers d'invites". Après soumission, elle renvoie immédiatement un ID de tâche, et une fois terminée, vous notifie via l'événement batch.succeeded contenant l'URI du fichier de sortie (output_file_uri). Dans ce mode, l'avantage en termes de coûts des webhooks est évident : le sondage (polling) traditionnel de milliers de tâches par lots saturerait instantanément vos quotas d'API.
Génération de vidéos longues (Veo)
Les tâches de génération de vidéos longues, comme avec Veo, prennent généralement plusieurs minutes. Il est impossible de laisser l'interface utilisateur en attente de chargement pendant tout ce temps. Les webhooks vous permettent de renvoyer immédiatement une réponse "Génération en cours, vous serez notifié une fois terminée" au frontend, puis de notifier l'utilisateur via votre propre système de push (WebSocket, APNs, SSE) une fois le travail finalisé.
🎯 Adaptation au contexte local : Les équipes développant des applications vidéo basées sur l'IA se préoccupent principalement de deux points : la stabilité de l'invocation de Gemini Veo et la réception rapide des notifications de fin de tâche. L'utilisation d'un service proxy API comme APIYI (apiyi.com) résout le premier point, tandis que le mécanisme piloté par les événements des webhooks de l'API Gemini résout parfaitement le second. La combinaison des deux constitue une solution robuste pour vos pipelines de génération vidéo longue.
Conseils de décision : faut-il migrer immédiatement vers les webhooks de l'API Gemini ?
Bien que les webhooks semblent globalement supérieurs au polling (interrogation), la nécessité d'une migration immédiate dépend de votre charge de travail actuelle. La matrice de décision ci-dessous vous aidera à évaluer rapidement votre situation.
| Votre situation | Recommandation de migration vers les webhooks Gemini API |
|---|---|
Utilisation principale de generateContent (synchrone) |
Non nécessaire (les webhooks ne couvrent pas ce cas) |
| Utilisation occasionnelle de Batch, quelques tâches par jour | Optionnel, mais peu d'avantages |
| Nombreuses tâches Batch, plus de centaines par jour | Fortement recommandé, élimine les tempêtes de polling |
| Génération de vidéos longues avec Veo | Fortement recommandé, amélioration notable de l'expérience |
| Flux de travail Deep Research / agents | Fortement recommandé, essentiel pour la progression asynchrone |
| Plateforme SaaS multi-tenant | Fortement recommandé, adaptation parfaite avec les Dynamic Webhooks |
💡 Parcours de migration : Il n'est pas nécessaire de tout changer d'un coup. Vous pouvez commencer par utiliser les webhooks pour les nouveaux services tout en conservant le polling pour les anciens, puis remplacer progressivement. Les deux implémentations de Google coexistent, et l'interface
GET /operationscôté client reste valide. Si vous prévoyez d'utiliser APIYI (apiyi.com) pour invoquer d'autres modèles, profitez-en pour unifier le bus d'événements de toutes vos tâches asynchrones afin de réduire les coûts de maintenance de vos systèmes de notification.
FAQ sur les webhooks de l'API Gemini
Les webhooks de l'API Gemini sont-ils payants ?
Selon le blog officiel, il n'y a pas de facturation séparée pour l'envoi des webhooks. Vous payez uniquement pour les tâches Gemini API soumises (tokens, durée de génération vidéo, volume de traitement Batch). L'envoi du webhook est initié par Google et ne consomme pas votre quota d'appels API.
Les serveurs situés en Chine peuvent-ils recevoir directement les webhooks de l'API Gemini ?
Oui, à condition que votre point de terminaison de rappel soit accessible depuis le réseau de Google. Si le point de terminaison est entièrement déployé en interne sans accès public, Google ne pourra pas effectuer l'envoi. La pratique courante consiste à placer le point de terminaison sur des nœuds de périphérie (edge) ou une passerelle accessible internationalement, puis à rediriger vers le réseau interne ; ou à utiliser un service comme APIYI (apiyi.com) qui prend en charge le service proxy API pour les webhooks, afin de recevoir les notifications sur une couche intermédiaire avant de les transférer vers votre système interne.
Les webhooks de l'API Gemini envoient-ils des doublons ? Comment les dédupliquer ?
Oui. Google propose une livraison "au moins une fois" (at-least-once). Toute instabilité réseau momentanée ou erreur 5xx occasionnelle sur votre point de terminaison déclenchera une nouvelle tentative. La pratique standard consiste à utiliser le webhook-id présent dans l'en-tête de la requête comme clé d'idempotence pour vérifier les doublons dans votre base de données ou Redis, et de renvoyer directement un code 2xx si la tâche a déjà été traitée.
Peut-on utiliser simultanément les webhooks statiques et dynamiques ?
Oui, et c'est même recommandé. Le modèle courant est d'utiliser un Webhook statique pour les "notifications globales de secours" (par exemple, tous les événements d'échec envoyés vers une alerte), tout en utilisant un Webhook dynamique pour le "routage dédié" sur les tâches critiques (par exemple, le résultat de la génération vidéo d'un client VIP envoyé directement vers son propre point de terminaison).
Comment déployer les webhooks de l'API Gemini en production ?
L'architecture recommandée est la suivante : Passerelle HTTPS → Middleware de vérification de signature → Réponse rapide 2xx → File d'attente de messages → Traitement asynchrone par un Worker backend. Cette architecture peut supporter les pics de trafic des webhooks et facilite la surveillance, la relecture et l'audit. Si vous utilisez déjà une passerelle d'invocation IA basée sur APIYI (apiyi.com), intégrer le point de terminaison des webhooks sera encore plus simple.
Quel est le lien entre les webhooks de l'API Gemini et les Server-Sent Events (SSE) ?
Ils résolvent des problèmes différents. Le SSE est une connexion longue "initiée par le client, flux de contenu poussé par le serveur", idéale pour les flux de tokens en temps réel. Le Webhook est une requête courte "initiée par le serveur, événement poussé entre serveurs", idéale pour les notifications de fin de tâche. Une application basée sur des agents utilise souvent les deux : le SSE pour l'interaction utilisateur et le Webhook pour les tâches longues en arrière-plan.
Résumé : La véritable portée des webhooks pilotés par les événements de l'API Gemini
Les webhooks de l'API Gemini ne sont pas qu'une simple mise à jour technique ; ils marquent une prise de position claire de Google sur l'évolution des applications d'IA. Pour Google, le modèle dominant ne sera plus le mode "chat" classique (requête-réponse), mais plutôt des pipelines d'agents complexes mêlant recherche approfondie (Deep Research), traitement de vidéos longues et inférence par lots (Batch). Ces pipelines exigent naturellement une architecture pilotée par les événements, et les webhooks ne font que déplacer cette responsabilité de la couche développeur vers la plateforme.
Pour les développeurs, l'arrivée des webhooks de l'API Gemini a une signification supplémentaire : elle permet à Gemini de s'aligner sur les capacités techniques d'OpenAI et d'Anthropic, qui supportaient déjà des mécanismes similaires. Cela signifie que, quel que soit le modèle choisi, le paradigme de développement des tâches asynchrones converge. En utilisant un point d'entrée unifié comme APIYI (apiyi.com), vous pouvez centraliser les notifications d'événements de Gemini, Claude et GPT sur un bus d'événements unique, garantissant ainsi que votre pipeline reste inchangé, même si vous changez de modèle.
Si vous développez des applications de traitement vidéo, de génération de contenu en masse ou d'automatisation par agents, c'est le moment idéal pour migrer vers des webhooks pilotés par les événements. La technologie est mature, la documentation officielle est complète et les bibliothèques communautaires permettent une intégration rapide. Le coût marginal de cette transition est quasi nul, tandis que les bénéfices (élimination du polling, réduction de la latence, économie de quotas) sont immédiats.
📚 Pour aller plus loin : Le blog officiel détaille le contexte de cette publication : blog.google ; pour la liste complète des événements, les champs de payload et des exemples de SDK, consultez le Gemini Cookbook : github.com/google-gemini/cookbook ; pour les spécifications de signature, veuillez consulter la documentation Standard Webhooks : standardwebhooks. Si vous avez besoin d'un canal de transfert stable pour appeler l'API Gemini, découvrez le site officiel d'APIYI : apiyi.com.
Auteur : Équipe APIYI — Spécialistes de l'ingénierie des API de grands modèles de langage et de l'infrastructure asynchrone. Nous proposons un service de transfert unifié pour les modèles Gemini, Claude et GPT. Plus d'informations sur apiyi.com.
