Tarification de l'API OpenAI | Calcul automatisé des coûts

OpenAI API est une API (Application Programming Interface) pour les services de la marque OpenAI, tels que ChatGPT et DALL·E 3. Avec des modèles d'IA aussi puissants, les API OpenAI deviennent l'une des API les plus utilisées dans leurs domaines respectifs. Cependant, leur utilisation n'est pas gratuite.

Cet article fournira une ventilation des prix de chaque modèle d'API d'OpenAI, ainsi qu'une méthode automatisée pour calculer le nombre de tokens et son coût lors de l'utilisation de l'API OpenAI.

Qu'est-ce que l'API OpenAI ?

L'API OpenAI est l'API de programme (Application Programming Interface) fournie par OpenAI. Avec l'API OpenAI, les développeurs peuvent utiliser des services de modèles d'IA tels que l'API GPT et l'API DALLE 3 via l'API OpenAI.

Avec l'API OpenAI, elle permet aux développeurs de créer des applications en utilisant les modèles d'IA d'OpenAI tels que ChatGPT et Dalle3, ou d'utiliser ces modèles d'IA pour créer les vôtres - le tout sans avoir à accéder à la page Web réelle pour obtenir ses fonctionnalités.

Entrer dans les détails : Tarification de l'API OpenAI

Au moment de la rédaction de cet article, il existe sept modèles d'IA recommandés qui fournissent des services d'API sous OpenAI, qui sont :

• GPT-4o
• GPT-4 Turbo
• GPT-4
• GPT-3.5 Turbo
• Assistants API
• Fine-tuning models
• Embedding models and basic models
• Image generation models (DALL·E 3)
• Audio models, and more.

GPT-4o

GPT-4o (« o » pour « omni ») est la dernière version du modèle jusqu'au 13 mai 2024. C'est également le modèle phare le plus rapide et le plus abordable. De plus, GPT-4o a la meilleure vision et les meilleures performances dans les langues non anglaises de tous nos modèles. GPT-4o est disponible dans l'API OpenAI pour les clients payants.

Tarification GPT-4 Turbo

GPT-4 Turbo est disponible en trois modèles : gpt-4-0125-preview, gpt-4-1106-preview et gpt-4-1106-vision-preview, tous au prix de 10,00 $ par 1 million de tokens d'entrée et 1 million de tokens de sortie. Le prix est fixé à 30,00 $ par article.

Bien que GPT-4 Turbo soit un modèle de traitement du langage naturel haute performance, on peut constater que les frais d'utilisation peuvent être plus élevés, en raison de meilleures performances.

Tarification GPT-4

Il existe deux options de tarification pour le modèle linguistique GPT-4.

1. gpt-4 : Il s'agit de la version standard de GPT-4. Il y a des frais de 30,00 $ par 1 million de tokens d'entrée et de 60,00 $ par 1 million de tokens de sortie.
2. gpt-4-32k : Il s'agit d'une version avancée de GPT-4 avec une longueur de contexte plus longue. Il est au prix de 60,00 $ par 1 million de tokens d'entrée et de 120,00 $ par 1 million de tokens de sortie, soit le double du prix du gpt-4 standard.

Les connaissances générales et de domaine étendues de GPT-4 et sa capacité à résoudre avec précision des problèmes difficiles en suivant des instructions complexes en langage naturel méritent d'être notées, cependant, pour obtenir le gpt-4-32k le plus performant, vous devrez payer le double de la version standard.

Tarification GPT-3.5 Turbo

La famille de modèles GPT-3.5 Turbo compte deux membres. Le modèle gpt-3.5-turbo-0125 est le modèle phare qui prend en charge les fenêtres contextuelles de 16K et est optimisé pour l'interaction. Le modèle gpt-3.5-turbo-instruct est un modèle instruit et ne prend en charge que les fenêtres contextuelles de 4K. Les frais respectifs seront de 0,5 USD et 1,5 USD pour 1 million de tokens d'entrée, tandis que 1,5 USD et 2 USD pour 1 million de tokens de sortie.

Tarification de l'API Assistants

Les développeurs peuvent utiliser l'API Assistants et les outils pour créer leurs propres applications d'assistant d'IA. La fonction de recherche entraîne des frais de stockage de fichiers pour chaque assistant, où la tarification est basée sur les frais de token pour le modèle linguistique sélectionné. Les deux sous-modèles, Code Interpreter et Retrieval, sont au prix de 0,03 USD/session et 0,2 USD/Go/assistant/jour.

Tarification du modèle de réglage fin

Lors de l'utilisation de modèles de réglage fin, les utilisateurs ne seront facturés que pour l'utilisation du modèle d'origine. Les frais respectifs pour les trois modèles tels que gpt-3.5-turbo, davinci-002 et babbage-002 seront de 8 USD, 6 USD et 0,41 M par 1 million de tokens d'entraînement, et de 3 USD et 12 USD par 1 million de tokens d'entrée. USD et 1,6 USD, et pour 1 million de tokens de sortie, ce sera 6 USD, 12 USD et 1,6 USD.

Tarification des modèles d'intégration et de base

Les modèles d'intégration sont assez abordables, où text-embedding-3-small est à 0,02 $ par 1 million de tokens, text-embedding-3-large est à 0,13 $ par 1 million de tokens et ada v2 est à 0,10 $ par 1 million de tokens.

Les frais de modèle de base sont de 2,00 $ par 1 million de tokens pour davinci-002 et de 0,40 $ pour babbage-002.

Prix du modèle de génération d'images (DALL·E 3)

La résolution standard de qualité 1024x1024 de DALL-E 3 coûte 0,04 $ par image, et la même résolution en HD coûte 0,08 $. DALL-E 2 est moins cher à des résolutions inférieures : 1024x1024 à 0,02 $, 512x512 à 0,018 $ et 256x256 à 0,016 $.

Résumé tabulé pour chaque tarification de modèle d'API OpenAI

Si vous souhaitez connaître les frais d'utilisation de tous les modèles, visitez le site Web officiel de l'API ChatGPT et consultez la liste de prix de l'API OpenAI.

Conditions préalables au calcul automatisé des coûts avec Apidog

Afin de travailler plus efficacement avec les API, nous vous recommandons vivement d'utiliser Apidog.

Apidog est une plateforme de développement d'API tout-en-un qui prend en charge les développeurs d'API tout au long du cycle de vie d'une API. Cela signifie qu'Apidog vous couvre avec des processus pour gérer les API, de la conception, en passant par les tests et la documentation.

Pour créer un calculateur automatique du coût d'exécution de l'API OpenAI, nous avons besoin d'une bibliothèque de conversion tierce pour convertir avec précision les entrées et les sorties en valeurs de token.

De plus, nous pourrons les convertir dans n'importe quelle devise, prenons l'exemple du JPY (yen japonais).

Bibliothèque de conversion de comptage de tokens

Ceci utilise la bibliothèque Open AI GPT Token Counter pour convertir les données d'entrée/de sortie en nombres de tokens pendant le processus de débogage de l'API.

Exemples de code Node.js :

const openaiTokenCounter = require('openai-gpt-token-counter');

const text = process.argv[2]; // Obtenez le contenu du test à partir des arguments de la ligne de commande
const model = "gpt-4"; // Remplacez par le modèle OpenAI que vous souhaitez utiliser

const tokenCount = openaiTokenCounter.text(text, model);
const characterCount = text.length; // Calculez le nombre de caractères

console.log(`${tokenCount}`);

Vous devez ensuite renommer le script Node.js en gpt-tokens-counter.js et le placer dans le répertoire du programme externe d'Apidog pour l'appeler.

Ensuite, vous devrez installer OpenAI GPT Token Counter sur votre ordinateur. Pour ce faire, vous pouvez utiliser la commande suivante dans votre terminal :

npm install openai-gpt-token-counter

API de taux de change en temps réel​

Après avoir obtenu les valeurs de tokens pour l'entrée et la sortie, il est nécessaire d'estimer le coût en JPY en utilisant une API de taux de change en temps réel. Cet article appellera l'API Currencylayer pour obtenir le taux de change en temps réel. Inscrivez-vous pour un compte et obtenez une clé API.

Conversion des valeurs d'entrée en tokens à l'aide d'Apidog

Les valeurs d'entrée peuvent être comprises comme des questions et des invites lorsqu'elles sont fournies par l'utilisateur lors de la requête de l'application d'IA. Pour en tirer parti, un script personnalisé doit être ajouté dans les pré-processeurs pour extraire le paramètre query du body de la requête, suivi de sa conversion en valeurs de token.

Voici l'exemple de code pour ajouter le script de conversion de valeur de token dans la section des pré-processeurs :

try {
  var jsonData = JSON.parse(pm.request.body.raw);
  var content = jsonData.messages[0].content; // obtient le contenu des messages
  var result_input_tokens_js = pm.execute('./gpt-tokens/gpt-tokens-counter.js',[content])
  console.log(content);
  pm.environment.set("RESULT_INPUT_TOKENS", result_input_tokens_js);
  console.log("Input Tokens count: " + pm.environment.get("RESULT_INPUT_TOKENS"));
} catch (e) {
    console.log(e);
}

Après avoir appuyé sur Envoyer, les valeurs d'entrée calculées doivent être visibles dans la section de la console Apidog.

Convertir les tokens en coût JPY

Après avoir obtenu la valeur des tokens consommés à partir de l'entrée, il est nécessaire de demander une API de taux de change en temps réel pour obtenir un facteur de conversion. Ce facteur est ensuite multiplié par la valeur des tokens pour calculer le coût réel en JPY. Ajoutez le script suivant à la pré-opération :

pm.sendRequest("http://apilayer.net/api/live?access_key=YOUR-API-KEY&currencies=JPY&source=USD&format=1", (err, res) => {
  if (err) {
    console.log(err);
  } else {
    const quotes = res.json().quotes;
    const rate = parseFloat(quotes.USDJPY).toFixed(3);
    pm.environment.set("USDJPY_RATE", rate); 
    var USDJPY_RATE = pm.environment.get("USDJPY_RATE");
    // Récupérer la variable RESULT_INPUT_TOKENS du script précédent
    var RESULT_INPUT_TOKENS = pm.environment.get("RESULT_INPUT_TOKENS");

    // Calculer la valeur du taux de change des tokens
    const tokensExchangeRate = 0.03; // Prix de 1000 tokens en USD (avec la tarification d'entrée du contexte GPT-4-8k comme référence)

    // Calculer le prix estimé en JPY
    const JPYPrice = ((RESULT_INPUT_TOKENS / 1000) * tokensExchangeRate * USDJPY_RATE).toFixed(2);

    pm.environment.set("INPUT_PRICE", JPYPrice); 

    console.log("Coût estimé : " + "¥" + JPYPrice);
  }
});

Conversion des valeurs de sortie en tokens à l'aide d'Apidog

Apidog analyse automatiquement les données renvoyées en tant qu'événement SSE (Server-Sent Events) lorsque le paramètre content-type dans la réponse renvoyée par l'API contient quelque chose comme text/event-stream.

Commencez par accéder à la section des post-processeurs dans la définition de l'API et ajoutez un script personnalisé pour extraire le contenu de la réponse et la concaténation de l'achèvement.

// Obtenez le texte de la réponse
const text = pm.response.text()
// Divisez le texte en lignes
var lines = text.split('\n');
// Créez un tableau vide pour stocker le paramètre "content"
var contents = [];
// Parcourez chaque ligne
for (var i = 0; i < lines.length; i++) {
    const line = lines[i];
    // Ignorez les lignes qui ne commencent pas par "data:"
    if (!line.startsWith('data:')) {
        continue;
    }
    // Essayez d'analyser les données JSON
    try {
        var data = JSON.parse(line.substring(5).trim());  // Supprimez le "data: " de début
        // Obtenez le paramètre "content" du tableau "choices" et ajoutez-le au tableau
        contents.push(data.choices[0].delta.content);
    } catch (e) {
        // Ignorez la ligne actuelle si ce ne sont pas des données JSON valides
    }
}
// Joignez les paramètres "content" en utilisant la méthode join()
var result = contents.join('');
// Affichez le résultat dans l'onglet "Visualiser" du corps
pm.visualizer.set(result);
// Imprimez le résultat dans la console
console.log(result);

Après avoir créé la requête, vous pouvez récupérer le contenu complet de la réponse dans la console !

Conversion des tokens à partir de la valeur de sortie à l'aide d'Apidog

Une fois que vous avez reçu le contenu de la réponse, il est nécessaire de le convertir en valeur de tokens. Ceci est rendu possible avec une bibliothèque tierce.

Ajoutez le script personnalisé dans l'opération de post-traitement afin qu'Apidog puisse appeler le script externe gpt-toejsn-counter.js pour obtenir la valeur des tokens.

Utilisez cette page pour voir le code spécifique :

Avec les chiffres que vous obtenez de la console, vous pouvez estimer combien cela coûtera !

// Obtenez le texte de la réponse
const text = pm.response.text()
// Divisez le texte en lignes
var lines = text.split('\n');
// Créez un tableau vide pour stocker le paramètre "content"
var contents = [];
// Parcourez chaque ligne
for (var i = 0; i < lines.length; i++) {
    const line = lines[i];
    // Ignorez les lignes qui ne commencent pas par "data:"
    if (!line.startsWith('data:')) {
        continue;
    }
    // Essayez d'analyser les données JSON
    try {
        var data = JSON.parse(line.substring(5).trim());  // Supprimez le "data: " de début
        // Obtenez le paramètre "content" du tableau "choices" et ajoutez-le au tableau
        contents.push(data.choices[0].delta.content);
    } catch (e) {
        // Ignorez la ligne actuelle si ce ne sont pas des données JSON valides
    }
}
// Joignez les paramètres "content" en utilisant la méthode join()
var result = contents.join('');
// Affichez le résultat dans l'onglet "Visualiser" du corps
pm.visualizer.set(result);
// Imprimez le résultat dans la console
console.log(result);

// Calculez le nombre de tokens de sortie.
var RESULT_OUTPUT_TOKENS = pm.execute('./gpt-tokens/gpt-tokens-counter.js', [result])
pm.environment.set("RESULT_OUTPUT_TOKENS", RESULT_OUTPUT_TOKENS);

console.log("Output Tokens count: " + pm.environment.get("RESULT_OUTPUT_TOKENS")); 

Convertir les tokens de sortie en coût JPY

Semblable au schéma de calcul des coûts mentionné dans la section précédente, le coût réel (JPY) est obtenu en multipliant la valeur des tokens par le taux de change.

Ajoutez le script suivant dans l'opération de post-traitement :

pm.sendRequest("http://apilayer.net/api/live?access_key=YOUR-API-KEY&currencies=JPY&source=USD&format=1", (err, res) => {
  if (err) {
    console.log(err);
  } else {
    const quotes = res.json().quotes;
    const rate = parseFloat(quotes.USDJPY).toFixed(3);
    pm.environment.set("USDJPY_RATE", rate); 
    var USDJPY_RATE = pm.environment.get("USDJPY_RATE");
    // Obtenez la variable RESULT_OUTPUT_TOKENS du script postman précédent
    var RESULT_OUTPUT_TOKENS = pm.environment.get("RESULT_OUTPUT_TOKENS");

    // Calculer le taux de change des tokens
    const tokensExchangeRate = 0.06; // Prix en USD pour 1000 tokens (basé sur la tarification d'entrée du contexte GPT-4-8k)

    // Calculer le prix estimé en JPY
    const JPYPrice = ((RESULT_OUTPUT_TOKENS / 1000) * tokensExchangeRate * USDJPY_RATE).toFixed(2);

    pm.environment.set("OUTPUT_PRICE", JPYPrice); 

    console.log("Coût de sortie (JPY) : " + JPYPrice + "円");
  }
});

Calculer le coût total en JPY

Enfin, ajoutez un script personnalisé dans la phase de post-traitement qui peut calculer automatiquement le coût total des entrées et des sorties.

// Addition des coûts d'entrée et de sortie

const INPUTPrice = Number(pm.environment.get("INPUT_PRICE"));
// Obtenez la variable de prix d'entrée et convertissez-la en nombre

const OUTPUTPrice = Number(pm.environment.get("OUTPUT_PRICE"));
// Obtenez la variable de prix de sortie et convertissez-la en nombre

console.log("Coût total : " + "￥" + (INPUTPrice + OUTPUTPrice));
// Imprimez le coût total : la somme du prix d'entrée et du prix de sortie.

Permettant d'estimer le coût approximatif de la requête en cours lors du processus de débogage de l'API.

Travailler sur les API OpenAI avec Apidog

Comme mentionné précédemment, Apidog est un outil d'API complet qui fournit la conception, la documentation, les tests et le débogage d'API, le tout au sein d'une seule application.

Avec d'innombrables autres API comme celle d'OpenAI, vous pouvez désormais trouver et accéder à ce type de projets d'API tiers avec le service API Hub d'Apidog.

Pour accéder au projet Open API sur API hub, cliquez sur ce lien ci-dessous. Vous pouvez accéder à toutes les API fournies par OpenAI !