Inférence Flex

L'API Gemini Flex est un niveau d'inférence qui offre une réduction des coûts de 50% par rapport aux tarifs standards, en échange d'une latence variable et d'une disponibilité optimale. Elle est conçue pour les charges de travail tolérantes à la latence qui nécessitent un traitement synchrone, mais qui n'ont pas besoin des performances en temps réel de l'API standard.

Utiliser Flex

Pour utiliser le niveau Flex, spécifiez service_tier comme flex dans votre requête. Par défaut, les requêtes utilisent le niveau standard si ce champ est omis.

Python

# This will only work for SDK newer than 2.0.0
from google import genai

client = genai.Client()

try:
    interaction = client.interactions.create(
        model="gemini-3-flash-preview",
        input="Analyze this dataset for trends...",
        service_tier='flex'
    )
    print(interaction.steps[-1].content[0].text)
except Exception as e:
    print(f"Flex request failed: {e}")

JavaScript

// This will only work for SDK newer than 2.0.0
import { GoogleGenAI } from '@google/genai';

const client = new GoogleGenAI({});

async function main() {
    try {
        const interaction = await client.interactions.create({
            model: 'gemini-3-flash-preview',
            input: 'Analyze this dataset for trends...',
            service_tier: 'flex'
        });
        console.log(interaction.steps.at(-1).content[0].text);
    } catch (e) {
        console.log(`Flex request failed: ${e}`);
    }
}
await main();

REST

# Specifies the API revision to avoid breaking changes when they become default
curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "Content-Type: application/json" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Api-Revision: 2026-05-20" \
  -d '{
      "model": "gemini-3-flash-preview",
      "input": "Analyze this dataset for trends...",
      "service_tier": "flex"
  }'

Fonctionnement de l'inférence Flex

L'inférence Gemini Flex comble le fossé entre l'API standard et le délai de traitement de 24 heures de l'API Batch. Elle utilise une capacité de calcul "réductible" en dehors des heures de pointe pour fournir une solution économique pour les tâches en arrière-plan et les workflows séquentiels.

Fonctionnalité Flex Priorité Standard Lot
Tarifs 50% de remise 75 à 100% de plus que Standard Plein tarif 50% de remise
Latence Minutes (cible de 1 à 15 minutes) Faible (secondes) Secondes à minutes Jusqu'à 24 heures
Fiabilité Optimisation limitée (réductible) Élevée (non réductible) Élevée / Moyenne haute Élevée (pour le débit)
Interface Synchrone Synchrone Synchrone Asynchrone

Principaux avantages

  • Rentabilité : économies substantielles pour les évaluations hors production, les agents en arrière-plan et l'enrichissement des données.
  • Faible friction : il vous suffit d'ajouter un seul paramètre à vos requêtes existantes.
  • Workflows synchrones : idéal pour les chaînes d'API séquentielles où la requête suivante dépend de la sortie de la précédente, ce qui la rend plus flexible que Batch pour les workflows d'agents.

Cas d'utilisation

  • Évaluations hors connexion : exécution de tests de régression ou de classements « LLM-as-a-judge ».
  • Agents en arrière-plan : tâches séquentielles telles que les mises à jour CRM, la création de profils ou la modération de contenu où quelques minutes de délai sont acceptables.
  • Recherche avec budget limité : expériences universitaires nécessitant un volume de jetons élevé avec un budget limité.

Limites de débit

Le trafic d'inférence Flex est comptabilisé dans vos limites de débit générales. Il n'offre pas de limites de débit étendues comme l'API Batch.

Capacité réductible

Le trafic Flex est traité avec une priorité inférieure. En cas de pic de trafic standard, les requêtes Flex peuvent être préemptées ou supprimées pour garantir la capacité des utilisateurs prioritaires. Si vous recherchez une inférence prioritaire, consultez la section Inférence prioritaire

Codes d'erreur

Lorsque la capacité Flex n'est pas disponible ou que le système est surchargé, l'API renvoie des codes d'erreur standards :

  • 503 Service Unavailable : le système est actuellement à pleine capacité.
  • 429 Too Many Requests : limites de débit ou épuisement des ressources.

Responsabilité du client

  • Aucune reprise côté serveur : pour éviter les frais inattendus, le système ne met pas automatiquement à niveau une requête Flex vers le niveau Standard si la capacité Flex est pleine.
  • Nouvelles tentatives : vous devez implémenter votre propre logique de nouvelle tentative côté client avec un intervalle exponentiel entre les tentatives.
  • Délais avant expiration : étant donné que les requêtes Flex peuvent se trouver dans une file d'attente, nous vous recommandons d’augmenter les délais avant expiration côté client à 10 minutes ou plus pour éviter une fermeture prématurée de la connexion.

Ajuster les fenêtres de délai avant expiration

Vous pouvez configurer des délais avant expiration par requête pour l'API REST et les bibliothèques clientes. Assurez-vous toujours que votre délai avant expiration côté client couvre la fenêtre de patience du serveur prévue (par exemple, 600 secondes ou plus pour les files d'attente Flex). Les SDK attendent des valeurs de délai avant expiration en millisecondes.

Délais avant expiration par requête

Python

from google import genai

client = genai.Client(http_options={"timeout": 900000})

try:
    interaction = client.interactions.create(
        model="gemini-3-flash-preview",
        input="why is the sky blue?",
        service_tier="flex",
    )
except Exception as e:
    print(f"Flex request failed: {e}")

JavaScript

import { GoogleGenAI } from '@google/genai';

const client = new GoogleGenAI({});

async function main() {
    try {
        const interaction = await client.interactions.create({
            model: "gemini-3-flash-preview",
            input: "why is the sky blue?",
            service_tier: "flex",
        }, {timeout: 900000});
    } catch (e) {
        console.log(`Flex request failed: ${e}`);
    }
}

await main();

Implémenter des nouvelles tentatives

Étant donné que Flex est réductible et échoue avec des erreurs 503, voici un exemple d'implémentation facultative d'une logique de nouvelle tentative pour poursuivre les requêtes ayant échoué :

Python

import time
from google import genai

client = genai.Client()

def call_with_retry(max_retries=3, base_delay=5):
    for attempt in range(max_retries):
        try:
            return client.interactions.create(
                model="gemini-3-flash-preview",
                input="Analyze this batch statement.",
                service_tier="flex",
            )
        except Exception as e:
            if attempt < max_retries - 1:
                delay = base_delay * (2 ** attempt) # Exponential Backoff
                print(f"Flex busy, retrying in {delay}s...")
                time.sleep(delay)
            else:
                # Fallback to standard on last strike (Optional)
                print("Flex exhausted, falling back to Standard...")
                return client.interactions.create(
                    model="gemini-3-flash-preview",
                    input="Analyze this batch statement."
                )

# Usage
interaction = call_with_retry()
print(interaction.steps[-1].content[0].text)

JavaScript

import { GoogleGenAI } from '@google/genai';

const ai = new GoogleGenAI({});

async function sleep(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

async function callWithRetry(maxRetries = 3, baseDelay = 5) {
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    try {
      console.log(`Attempt ${attempt + 1}: Calling Flex tier...`);
      const interaction = await ai.interactions.create({
        model: "gemini-3-flash-preview",
        input: "Analyze this batch statement.",
        service_tier: 'flex',
      });
      return interaction;
    } catch (e) {
      if (attempt < maxRetries - 1) {
        const delay = baseDelay * (2 ** attempt);
        console.log(`Flex busy, retrying in ${delay}s...`);
        await sleep(delay * 1000);
      } else {
        console.log("Flex exhausted, falling back to Standard...");
        return await ai.interactions.create({
          model: "gemini-3-flash-preview",
          input: "Analyze this batch statement.",
        });
      }
    }
  }
}

async function main() {
    const interaction = await callWithRetry();
    console.log(interaction.steps.at(-1).content[0].text);
}

await main();

Tarifs

L'inférence Flex est facturée à 50% de l'API standard et facturée par jeton.

Modèles compatibles

Les modèles suivants sont compatibles avec l'inférence Flex :

Modèle Inférence Flex
Gemini 3.1 Flash-Lite ✔️
Preview Gemini 3.1 Flash-Lite ✔️
Preview Gemini 3.1 Pro ✔️
Preview Gemini 3 Flash ✔️
Gemini 2.5 Pro ✔️
Gemini 2.5 Flash ✔️
Gemini 2.5 Flash-Lite ✔️

Étape suivante