Responses API completion_window : réductions avec 2h et 8h
Configurez les requêtes Responses API en arrière-plan avec une réduction et des champs correctement imbriqués. Comparez soonest, 2h et 8h, récupérez les résultats et conservez les conditions de priorité ainsi que l’historique entre les requêtes.
Sommaire

Si les analyses API de votre équipe peuvent attendre plusieurs heures, utilisez une fenêtre de finalisation Responses API pour réduire les frais de tokens éligibles. Définissez background_options.completion_window sur 2h ou 8h, avec background: true et service_tier: "default". Suivez les réglages documentés des fenêtres de finalisation : ne placez pas completion_window au niveau supérieur et n’activez pas le streaming pour ces fenêtres avec réduction.
Choisissez soonest, 2h ou 8h
Choisissez la fenêtre selon le moment où vous avez besoin de la première réponse, pas selon le temps de réflexion estimé du modèle. Au 2026-11-19, le guide du mode en arrière-plan d’OpenAI définit les options et réductions suivantes.
| Fenêtre | Réduction sur les tokens du modèle par rapport à Standard | Quand l’utiliser |
|---|---|---|
soonest | Aucune ; c’est la valeur par défaut | Une personne attend le résultat immédiatement. |
2h | 30% | L’analyse peut se terminer avant une réunion ultérieure ou la prochaine étape de traitement. |
8h | 40% | Une analyse de documents ou une revue nocturne peut attendre le lendemain matin. |
Définir uniquement background: true n’active pas de réduction. Sans fenêtre de finalisation explicite, la requête utilise soonest. Pour 2h et 8h, le délai cible commence lorsque l’API accepte la requête initiale et concerne cette réponse. Ce n’est pas un délai global couvrant tous les appels d’outils et toutes les requêtes suivantes.
Pour un exemple de calcul limité aux tokens, supposons une requête Astra avec 100,000 tokens d’entrée non mis en cache et 10,000 tokens de sortie facturés. Supposons aussi qu’il n’y ait ni écriture en cache, ni outil payant, ni frais de stockage, ni majoration régionale de traitement.
Au 2026-11-19, la grille tarifaire Standard d’OpenAI indique, pour Astra en contexte court, $8 par 1M tokens d’entrée et $40 par 1M tokens de sortie. La fiche du modèle Astra prévoit des ajustements de contexte long au-delà de 272K tokens d’entrée. Les 100,000 tokens d’entrée de cet exemple restent sous ce seuil.
Le coût estimé des tokens du modèle avec Standard est le suivant :
(100,000 / 1,000,000 × $8) + (10,000 / 1,000,000 × $40) = $1.20
Pour les mêmes quantités de tokens, 2h donne $1.20 × 0.70 = $0.84 et 8h donne $1.20 × 0.60 = $0.72. Il s’agit d’exemples calculés, pas de frais mesurés sur des requêtes exécutées.
La réduction porte sur les tarifs des tokens du modèle pour chaque requête éligible, y compris les suivantes. N’appliquez pas ce pourcentage aux autres postes de la facture. Pour les traitements avec cache, calculez séparément les écritures et les lectures à l’aide du guide des coûts du cache de prompts.
Vérifiez le modèle et choisissez un mode d’accès
Utilisez directement Responses API d’OpenAI pour disposer des réglages documentés des fenêtres de finalisation. Au 2026-11-19, la liste des modèles éligibles cite GPT-6.2 Astra, GPT-6.2 Sol, GPT-6.1 Terra et GPT-6 Luna pour la bêta publique. Les identifiants des modèles GPT-6.2 sont gpt-6.2-astra et gpt-6.2-sol.
Pour choisir un modèle et préparer la migration, consultez le guide API de GPT-6.2 Astra et Sol. Choisissez le mode d’accès indépendamment du modèle :
| Mode d’accès | Prérequis | Quand le choisir |
|---|---|---|
| OpenAI Responses API | Un projet et une clé d’API, un accès depuis un pays ou territoire pris en charge, ainsi qu’une facturation API configurée ou des crédits API disponibles. L’usage est facturé séparément de l’abonnement ChatGPT. | Vous avez besoin des réglages 2h ou 8h, notamment lorsque les requêtes suivantes dépendent des résultats précédents. |
| OpenAI Batch API | Les mêmes conditions d’accès et de facturation API, plus l’envoi de requêtes indépendantes dans un fichier. | Toutes les entrées sont connues à l’avance. Utilisez le fonctionnement de Batch API plutôt que de coordonner des étapes dépendantes. |
| BetterToken | Votre propre compte et clé d’API, un client compatible et un moyen de paiement proposé dans la console. L’usage suit l’unité de facturation de chaque modèle. | Vous comparez différentes possibilités d’accès aux modèles avec paiement à l’usage. Consultez les tarifs de BetterToken et vérifiez séparément la prise en charge des fenêtres de finalisation avant de faire passer ce traitement par une passerelle. |
Ne supposez pas qu’un abonnement ChatGPT ou Codex donne accès à ces options de requête. La méthode documentée ici passe par une requête Responses API, avec une facturation API distincte de ChatGPT. L’authentification par clé d’API de Codex utilise la facturation API plutôt que les crédits inclus dans l’offre. Cela ne suffit pas à établir que Codex propose un réglage de fenêtre de finalisation.
Imbriquez correctement les champs dans background_options
Placez completion_window et continuation_id dans background_options. Laissez background, service_tier et stream au niveau supérieur, conformément au schéma des requêtes Responses. Le traitement Standard est obligatoire ; service_tier: "default" sélectionne ce mode.
L’exemple Bash suivant nécessite curl, jq et uuidgen. Exécutez tous les blocs dans la même session de shell et le même répertoire de travail. Lorsque read attend une saisie, collez votre clé d’API OpenAI et appuyez sur Enter. La clé ne s’affiche pas et n’entre pas dans l’historique des commandes.
Cet exemple génère un identifiant de continuation, car il montrera ensuite une seconde requête. Il demande à l’API de conserver les réponses et écrit des fichiers JSON locaux. Vérifiez vos exigences de traitement des données avant de remplacer le contenu par des documents sensibles.
set +x
set -euo pipefail
read -rs OPENAI_API_KEY && export OPENAI_API_KEY
CONTINUATION_ID=$(uuidgen)
jq -n --arg continuation_id "$CONTINUATION_ID" '{
model: "gpt-6.2-astra",
input: "Review this migration plan for risks: add a nullable column, backfill it in batches, switch reads, then enforce NOT NULL.",
background: true,
service_tier: "default",
stream: false,
store: true,
background_options: {
completion_window: "8h",
continuation_id: $continuation_id
}
}' > background-request.json
curl --fail-with-body --silent --show-error \
https://api.openai.com/v1/responses \
-H "Authorization: Bearer $OPENAI_API_KEY" \
-H "Content-Type: application/json" \
--data-binary @background-request.json \
--output background-response.json
jq -er '.id' background-response.json > background-response-id.txt
jq '{id, status, service_tier}' background-response.json
La première vérification consiste à recevoir un id de réponse, enregistré dans background-response-id.txt. Un statut queued ou in_progress signifie que le résultat n’est pas encore prêt. Conservez cet ID au lieu de soumettre à nouveau le même travail.
Interrogez la réponse par son ID ou utilisez un webhook
Récupérez la réponse existante avec GET /v1/responses/{response_id}. La boucle suivante poursuit les interrogations uniquement pour queued et in_progress. Elle se termine normalement à completed et affiche des informations pour les autres états finaux. L’intervalle de 30 secondes est un choix de l’exemple, pas une exigence de l’API.
RESPONSE_ID=$(cat background-response-id.txt)
while :; do
curl --fail-with-body --silent --show-error \
"https://api.openai.com/v1/responses/$RESPONSE_ID" \
-H "Authorization: Bearer $OPENAI_API_KEY" \
--output background-response.json
STATUS=$(jq -r '.status' background-response.json)
case "$STATUS" in
queued|in_progress) sleep 30 ;;
completed) break ;;
*)
jq '{id, status, error, incomplete_details}' background-response.json
exit 1
;;
esac
done
cp background-response.json "$RESPONSE_ID.json"
jq '{id, status, service_tier, usage}' background-response.json
jq -r '.output[]? | select(.type == "message") |
.content[]? | select(.type == "output_text") | .text' \
background-response.json
Dans cet exemple textuel, la réussite correspond au statut completed et à l’affichage de l’analyse extraite du message de réponse. L’extraction vérifie les types des éléments au lieu de supposer que le premier élément de sortie contient du texte. Si une récupération HTTP échoue, conservez le fichier d’ID et relancez le bloc d’interrogation, pas celui de soumission.
En production, suivez les instructions de réception des webhooks plutôt que de garder un shell ouvert. Abonnez-vous à response.completed, vérifiez la signature reçue et récupérez la réponse désignée par event.data.id. Dédupliquez les livraisons avec webhook-id avant de lancer le travail suivant. Prévoyez aussi le traitement des résultats qui ne se terminent pas correctement.
Poursuivez le traitement sans perdre l’historique ni la priorité
Réutilisez la fenêtre de finalisation, l’identifiant de continuation, le modèle et le projet API pour rendre les requêtes liées éligibles à une priorité accrue. Conservez le traitement Standard et l’exécution en arrière-plan pour la requête suivante. Dans le fonctionnement des requêtes successives, OpenAI conditionne la priorité à la planification de la file ; aucun démarrage immédiat n’est promis.
Les identifiants remplissent des rôles différents. background_options.continuation_id est choisi par l’application pour planifier les requêtes ; il ne fournit pas l’historique de conversation. previous_response_id désigne la réponse précédente et permet de poursuivre la conversation tant que cette réponse reste disponible.
Une fois la première requête terminée, ce bloc conserve son modèle, sa fenêtre, son identifiant de continuation et ses réglages de traitement. Il ajoute l’ID de la réponse précédente et une nouvelle instruction. Utilisez une clé du même projet API pendant tout le traitement.
RESPONSE_ID=$(cat background-response-id.txt)
jq --arg previous_response_id "$RESPONSE_ID" \
'.previous_response_id = $previous_response_id |
.input = "Turn the two highest-risk findings into acceptance tests."' \
background-request.json > background-followup.json
curl --fail-with-body --silent --show-error \
https://api.openai.com/v1/responses \
-H "Authorization: Bearer $OPENAI_API_KEY" \
-H "Content-Type: application/json" \
--data-binary @background-followup.json \
--output background-response.json
jq -er '.id' background-response.json > background-response-id.txt
Exécutez à nouveau le bloc d’interrogation pour récupérer cette nouvelle réponse. La requête suivante est facturée séparément ; les tarifs de tokens éligibles bénéficient de la réduction choisie. Conserver les réglages de continuation donne droit à une priorité, pas à une réduction supplémentaire. L’historique transmis dans la chaîne compte toujours parmi les tokens d’entrée facturés.
Pour les traitements qui utilisent des appels de fonctions, envoyez un élément d’entrée function_call_output contenant le call_id d’origine et le résultat de l’outil dans output. Le guide des appels de fonctions décrit cet échange. Ne remplacez pas le mécanisme d’historique par un identifiant de continuation : celui-ci ne peut pas reconstituer une réponse expirée.
Vérifiez la file et la facturation avant d’augmenter le volume
Planifiez les requêtes en arrière-plan avec réduction en même temps que les travaux Batch. Les requêtes utilisant 2h ou 8h partagent la Batch/Background Rate Limit, et les tokens d’entrée sont comptabilisés à la soumission. Vérifiez cette capacité commune avant d’augmenter le volume de travaux programmés. Le solde monétaire disponible constitue une condition distincte.
Si la soumission échoue, comparez le paramètre signalé au schéma de requête avant de réessayer avec un petit travail. Selon l’erreur, vérifiez l’imbrication des champs, l’éligibilité du modèle, le traitement Standard et l’absence de streaming. Recevoir un ID confirme l’acceptation ; récupérez la réponse pour vérifier que la génération se termine réellement.
Si les frais semblent ne pas inclure la réduction, cherchez une fenêtre explicite 2h ou 8h dans la requête enregistrée, pas seulement background: true. Vérifiez le service_tier de la réponse, qui indique le mode de traitement réellement utilisé. Conservez le JSON envoyé et le usage retourné, puis rapprochez le premier travail des tarifs API actuels avant d’appliquer la configuration à toute la file.