OpenAI, modèles et API pour développeurs

En novembre 2022, OpenAI a lancé ChatGPT, et en 5 jours, plus d'un million d'utilisateurs se sont inscrits. Aujourd'hui, l'entreprise est valorisée à 852 milliards de dollars, et ses produits, de GPT-5 à Sora en passant par DALL-E, donnent le cap à toute l'industrie. Pour un développeur, OpenAI reste avant tout une plateforme API, avec des modèles, des outils et des bibliothèques sur lesquels construire ses propres applications.

Qu'est-ce qu'OpenAI ?

OpenAI est une entreprise américaine de recherche et de technologie en intelligence artificielle, fondée en décembre 2015 par Sam Altman, Elon Musk, Ilya Sutskever, Greg Brockman et d'autres. Elle a d'abord fonctionné comme une organisation à but non lucratif, avec pour mission de développer une intelligence artificielle générale (AGI) « sûre et bénéfique ».

Depuis 2019, OpenAI a connu une transformation structurelle : d'une organisation purement non lucrative vers un modèle hybride à « profit plafonné », puis, en 2025, vers une société à mission d'intérêt public (PBC) placée sous la supervision de la fondation OpenAI Foundation. Cette évolution tient à un fait simple : développer l'IA demande des ressources financières et de calcul considérables.

Le siège de l'entreprise se trouve à San Francisco. Son PDG est Sam Altman, et l'entreprise emploie des milliers de salariés et de chercheurs.

Histoire et moments clés

2015-2018 : les débuts

OpenAI a été fondée avec un engagement de 1 milliard de dollars de la part d'Altman, Musk, Reid Hoffman, Peter Thiel, AWS et d'autres. L'objectif était de mener une recherche ouverte sur l'IA, d'où le « Open » du nom. En 2018, Elon Musk a quitté le conseil d'administration après une tentative infructueuse de prendre le contrôle de l'organisation.

2019-2022 : GPT et la percée

En 2019, GPT-2 voit le jour et surprend tout le monde par la qualité du texte généré. GPT-3 (2020), avec ses 175 milliards de paramètres, lance l'ère des grands modèles de langage. En 2021 apparaissent DALL-E (génération d'images) et Codex (génération de code). GPT-3.5 et ChatGPT (novembre 2022) déclenchent le boom mondial de l'IA.

2023 : turbulences et GPT-4

En mars 2023, OpenAI lance GPT-4, un modèle multimodal qui comprend à la fois le texte et les images. En novembre, le conseil d'administration démet Sam Altman de son poste de PDG. Cinq jours plus tard, il revient, après que pratiquement tous les employés ont menacé de partir. La crise entraîne une reconstruction du conseil d'administration.

2024-2025 : modèles de raisonnement et GPT-5

OpenAI introduit la série de modèles o1/o3/o4-mini, capables de « réfléchir » : les modèles peuvent raisonner étape par étape avant de répondre. En 2025 apparaît GPT-5, qui unifie intelligence générale, raisonnement, codage et multimodalité dans une seule famille de modèles. Sortent aussi Sora 2 (vidéo), Operator (agent web), ChatGPT Atlas (navigateur) et GPT-OSS (modèles à poids ouverts).

En mai 2025, OpenAI rachète pour 6,5 milliards de dollars l'entreprise IO, fondée par Jony Ive (ancien directeur du design chez Apple), avec le projet de créer une nouvelle catégorie d'appareils personnels.

Le 31 mars 2026, l'entreprise a bouclé un tour de financement de 122 milliards de dollars, portant sa valorisation à 852 milliards. Amazon en a pris la plus grosse part, avec Nvidia et SoftBank, et une partie du tour a été ouverte aux investisseurs particuliers. À ces montants, il vaut la peine de se rappeler qu'une valorisation ne dit rien de la stabilité de la grille tarifaire de l'API, qui a changé plusieurs fois sur la même période.

Les produits OpenAI

ChatGPT

Le produit phare d'OpenAI pour le grand public. Une interface de chat pour interagir avec les modèles GPT :

• ChatGPT Free - accès gratuit à GPT-4o mini
• ChatGPT Plus ($20/mois) - GPT-4o, GPT-5, DALL-E, analyse de données
• ChatGPT Pro ($200/mois) - accès illimité à tous les modèles, o1-pro, deep research
• ChatGPT Team ($25/personne/mois) - version pour les équipes
• ChatGPT Enterprise - version entreprise avec conformité et SSO

DALL-E / gpt-image

Des modèles de génération d'images à partir de descriptions textuelles. DALL-E 3 est intégré à ChatGPT. En 2025, OpenAI est passé aux modèles gpt-image, basés sur les capacités multimodales de GPT, remplaçant les anciens modèles de diffusion.

Sora

Un modèle texte-vers-vidéo qui génère des vidéos jusqu'à une résolution de 1920x1080. Sora 2 (2025) propose une simulation physique améliorée et un son synchronisé.

Whisper

Un modèle de reconnaissance vocale : transcription audio-vers-texte avec prise en charge de nombreuses langues (dont le français). Open source, également disponible via l'API.

Operator

Un agent IA pour automatiser des tâches dans le navigateur : se connecter, remplir des formulaires, naviguer sur des sites.

Modèles OpenAI pour développeurs

Famille GPT-5

Les trois modèles de la ligne 5.6 partagent le même contexte de 1,05 million de tokens et la même limite de sortie de 128 000 tokens ; ils se distinguent par leur niveau de capacité et leur prix. Un tiret dans la colonne contexte signifie que la documentation ne donne cette valeur que pour la ligne actuelle : pour les modèles plus anciens, vérifie-la directement dans la description du modèle.

Famille GPT-4

Modèles de raisonnement (série O)

Les modèles de la série O consomment des « tokens de raisonnement » pour leur réflexion interne : ces tokens sont facturés comme de la sortie, mais ne sont pas visibles dans la réponse de l'API. Une réponse avec 500 tokens visibles peut ainsi consommer 2 000 tokens ou plus.

Modèles spécialisés

• gpt-image-1.5 - génération d'images
• gpt-4o-transcribe / whisper-1 - transcription audio
• gpt-4o-mini-tts - synthèse vocale (text-to-speech)
• text-embedding-3-small/large - embeddings de texte

Comment choisir un modèle ?

• Prototypage : GPT-5 Nano ou GPT-4o Mini (les moins chers)
• Applications générales : GPT-4o ou GPT-5
• Raisonnement complexe : gpt-5.6-sol ou o3
• Codage : GPT-4.1 (optimisé pour les instructions)
• Traitement en masse : GPT-4o Mini + Batch API (50 % moins cher)

API Responses

L'API Responses est la plus récente API d'OpenAI : elle combine la simplicité de Chat Completions avec les outils intégrés de l'API Assistants. Elle remplace l'ancienne API Assistants (dépréciée, suppression prévue en août 2026).

Utilisation de base

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-4o",
    input="Explique ce qu'est React en 3 phrases"
)
print(response.output_text)

Avec des outils intégrés

response = client.responses.create(
    model="gpt-4o",
    tools=[{"type": "web_search_preview"}],
    input="Quels sont les derniers changements de Next.js 15 ?"
)
print(response.output_text)

Streaming

stream = client.responses.create(
    model="gpt-4o",
    input="Écris un tutoriel sur les generics TypeScript",
    stream=True
)
for event in stream:
    if hasattr(event, "delta"):
        print(event.delta, end="", flush=True)

API Chat Completions

L'API classique pour générer des réponses au format conversation :

from openai import OpenAI

client = OpenAI()

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {"role": "system", "content": "Tu es un assistant de programmation utile."},
        {"role": "user", "content": "Comment créer un hook personnalisé en React ?"}
    ]
)
print(response.choices[0].message.content)

Structured Outputs

Forcer les réponses dans un schéma JSON défini :

from pydantic import BaseModel

class CodeReview(BaseModel):
    issues: list[str]
    suggestions: list[str]
    score: int

response = client.beta.chat.completions.parse(
    model="gpt-4o",
    messages=[
        {"role": "system", "content": "Analyse le code et retourne une review."},
        {"role": "user", "content": "function add(a,b){return a+b}"}
    ],
    response_format=CodeReview
)
review = response.choices[0].message.parsed
print(f"Score : {review.score}")
print(f"Problèmes : {review.issues}")

Function calling

Permet au modèle d'appeler des fonctions externes :

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Obtenir la météo actuelle pour un lieu",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {"type": "string", "description": "Nom de la ville"},
                    "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]}
                },
                "required": ["location"]
            }
        }
    }
]

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Quelle est la météo à Varsovie ?"}],
    tools=tools,
    tool_choice="auto"
)

tool_call = response.choices[0].message.tool_calls[0]
print(f"Fonction : {tool_call.function.name}")
print(f"Arguments : {tool_call.function.arguments}")

Vision (analyse d'images)

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Qu'est-ce que tu vois sur cette capture d'écran ?"},
                {"type": "image_url", "image_url": {"url": "https://example.com/screenshot.png"}}
            ]
        }
    ]
)
print(response.choices[0].message.content)

Embeddings

Les embeddings transforment du texte en vecteurs numériques qui reflètent le sens. Des textes proches par le sens génèrent des vecteurs proches.

response = client.embeddings.create(
    model="text-embedding-3-small",
    input="TypeScript est un sur-ensemble de JavaScript avec des types statiques"
)
embedding = response.data[0].embedding
print(f"Dimensions : {len(embedding)}")

Cas d'usage des embeddings

• Recherche sémantique - trouver des documents par le sens, pas par mots-clés
• RAG (Retrieval-Augmented Generation) - fournir du contexte aux modèles
• Classification - catégoriser des textes
• Recommandations - suggérer un contenu similaire
• Détection d'anomalies - repérer des schémas inhabituels

Comparaison des modèles d'embeddings

Pour la plupart des applications, text-embedding-3-small offre une qualité suffisante pour un sixième du coût de la version large.

SDK Agents

Le SDK Agents est le framework d'OpenAI pour construire des agents IA : des programmes capables d'exécuter de façon autonome des tâches à plusieurs étapes, en utilisant des outils et en déléguant du travail à d'autres agents.

Puisque l'interface d'OpenAI est devenue un standard de fait, il vaut la peine de savoir que des intermédiaires la parlent aussi. OpenRouter expose la même forme d'appel pour des modèles venant de dizaines de fournisseurs : changer de modèle revient à changer une seule chaîne de caractères, et si un fournisseur tombe en panne, le trafic bascule vers le suivant. Ce service se paie via une surtaxe au moment de recharger le compte, pas sur les tokens eux-mêmes.

Cette même forme d'appel peut aussi tourner sur ta propre infrastructure. LiteLLM fonctionne comme une bibliothèque ou comme une passerelle avec ses propres clés, limites et budgets par équipe, ce qui garde la facturation sous ton contrôle. Vérifie quand même la licence avant de déployer : le cœur est sous licence MIT, mais l'installation de l'extra proxy entraîne un paquet soumis à des conditions commerciales séparées.

La même interface peut aussi être la voie vers un profil de performance complètement différent. Groq fait tourner des modèles à poids ouverts sur sa propre puce et renvoie des centaines de tokens par seconde, ce qui fait passer un agent qui exécute une dizaine d'étapes de plusieurs minutes à quelques secondes. En échange, le catalogue est bien plus étroit : il ne couvre que des modèles à poids ouverts, et la liste des variantes retirées grossit plus vite que chez les fournisseurs généralistes.

Agent de base (Python)

from agents import Agent, Runner

agent = Agent(
    name="code-reviewer",
    instructions="Tu es un relecteur de code expert. Analyse le code à la recherche de bugs, de problèmes de sécurité et de problèmes de performance.",
    model="gpt-4o"
)

result = Runner.run_sync(agent, "Passe en revue cette fonction : def add(a,b): return a+b")
print(result.final_output)

Agent avec des outils

from agents import Agent, Runner, function_tool

@function_tool
def search_docs(query: str) -> str:
    """Recherche dans la documentation du projet"""
    return f"Documentation trouvée pour : {query}"

@function_tool
def run_tests(file_path: str) -> str:
    """Lance les tests d'un fichier donné"""
    return f"Tous les tests sont passés pour {file_path}"

agent = Agent(
    name="dev-assistant",
    instructions="Aide les développeurs en recherchant dans la documentation et en lançant les tests.",
    tools=[search_docs, run_tests],
    model="gpt-4o"
)

result = Runner.run_sync(agent, "Vérifie si le module auth a une documentation et lance ses tests")
print(result.final_output)

SDK Agents (TypeScript)

import { Agent, run } from "@openai/agents"

const agent = new Agent({
  name: "assistant",
  instructions: "Tu es un assistant de code utile.",
  model: "gpt-4o",
})

const result = await run(agent, "Explique les hooks React")
console.log(result.finalOutput)

Handoffs (délégation)

Les agents peuvent déléguer des tâches à d'autres agents :

from agents import Agent, Runner

researcher = Agent(
    name="researcher",
    instructions="Recherche les sujets en profondeur et fournis des résultats détaillés."
)

writer = Agent(
    name="writer",
    instructions="Écris un contenu clair et engageant à partir de recherches.",
    handoffs=[researcher]
)

result = Runner.run_sync(writer, "Écris un article sur WebAssembly")
print(result.final_output)

Outils intégrés

• web_search - recherche sur internet
• file_search - recherche dans des documents
• code_interpreter - exécution de code Python
• image_generation - création d'images
• computer_use - automatisation de l'interface

Codex CLI

Un outil open source pour coder en mode agent dans le terminal :

npx @openai/codex "Ajoute la gestion des erreurs au module auth"

Codex travaille directement avec ton dépôt : il lit les fichiers, propose des changements, et te laisse les relire et les accepter. Il s'intègre au SDK Agents via MCP (Model Context Protocol).

Optimisation des coûts

Avec des agents qui écrivent et exécutent du code, une question supplémentaire se pose : où ce code doit-il s'exécuter. Le faire tourner sur ton propre serveur applicatif est simple jusqu'à la première boucle infinie ou la première tentative d'accéder au système de fichiers. E2B fournit des machines isolées qui démarrent en une fraction de seconde, facturées au temps d'exécution, ce qui déplace le risque hors de ta propre infrastructure.

Prompt caching

OpenAI met automatiquement en cache les préfixes de prompt répétés :

Batch API

Pour des tâches qui n'ont pas besoin d'une réponse immédiate (analyse de données, génération de contenu) :

batch = client.batches.create(
    input_file_id="file-abc123",
    endpoint="/v1/chat/completions",
    completion_window="24h"
)

L'API Batch traite les requêtes en 24 heures avec une remise de 50 %.

Architecture en cascade

Une stratégie efficace consiste à router les requêtes vers des modèles de puissance croissante :

1. GPT-4o Mini traite 80 % des requêtes simples ($0.15/1M en entrée)
2. GPT-4o traite 15 % des requêtes moyennes ($2.50/1M en entrée)
3. o3 traite 5 % des requêtes complexes ($2.00/1M en entrée + raisonnement)

Fine-tuning

Entraîner un modèle sur tes propres données :

file = client.files.create(
    file=open("training_data.jsonl", "rb"),
    purpose="fine-tune"
)

job = client.fine_tuning.jobs.create(
    training_file=file.id,
    model="gpt-4.1-2025-04-14"
)

Le fine-tuning est disponible pour GPT-4.1, GPT-4o et o4-mini. Coût d'entraînement : $1.50-$100/h selon le modèle.

SDK et bibliothèques

Python

pip install openai

from openai import OpenAI

client = OpenAI()  # lit automatiquement OPENAI_API_KEY depuis l'environnement

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Bonjour !"}]
)

Node.js / TypeScript

npm install openai

import OpenAI from "openai"

const client = new OpenAI()

const response = await client.chat.completions.create({
  model: "gpt-4o",
  messages: [{ role: "user", content: "Bonjour !" }],
})
console.log(response.choices[0].message.content)

.NET

dotnet add package OpenAI

REST API (curl)

curl https://api.openai.com/v1/chat/completions \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-4o",
    "messages": [{"role": "user", "content": "Bonjour !"}]
  }'

API Audio

Transcription (Speech-to-Text)

audio_file = open("meeting.mp3", "rb")
transcript = client.audio.transcriptions.create(
    model="gpt-4o-transcribe",
    file=audio_file
)
print(transcript.text)

Text-to-Speech

response = client.audio.speech.create(
    model="gpt-4o-mini-tts",
    voice="alloy",
    input="TypeScript est un sur-ensemble de JavaScript."
)
response.stream_to_file("output.mp3")

Génération d'images

response = client.images.generate(
    model="gpt-image-1",
    prompt="Une ville futuriste avec des voitures volantes, style cyberpunk",
    size="1024x1024",
    n=1
)
print(response.data[0].url)

Sécurité et confidentialité

Politique de données de l'API

• Les données envoyées via l'API ne sont pas utilisées pour entraîner les modèles (par défaut)
• OpenAI conserve les données de l'API pendant 30 jours pour la surveillance des abus
• Zero Data Retention (ZDR) disponible pour les clients éligibles
• Conformité SOC 2 Type II

Rate limits

Les limites dépendent du Tier de l'utilisateur (Tier 1 à 5), qui augmente avec les dépenses :

Clés API

export OPENAI_API_KEY="sk-..."

Ne commite jamais de clés API dans ton dépôt. Utilise des variables d'environnement ou un gestionnaire de secrets.

Comparaison avec la concurrence

Ce tableau reflète l'état des choses à la publication et vieillit plus vite que tout le reste de ce texte. Les prix d'entrée correspondent au modèle le moins cher de la gamme de chaque fournisseur, pas à celui de la première ligne. Avant une décision budgétaire, vérifie les tarifs directement chez le fournisseur, car dans ce secteur ils changent sur un cycle mensuel plutôt qu'annuel.

Une remarque pratique pour le choix : les benchmarks publics mesurent des tâches qui ressemblent rarement aux tiennes. Construis une couche fine avec une seule interface d'appel et compare deux fournisseurs sur tes propres données. C'est le seul test qui dise vraiment quelque chose. Si les données ne peuvent pas quitter l'entreprise, ajoute à la comparaison un modèle qui tourne en local via Ollama, et pour construire des flux à plusieurs étapes, LangChain uniformise l'interface.

Cas d'usage pratiques

Chatbot avec contexte

messages = [
    {"role": "system", "content": "Tu es l'assistant d'une boutique en ligne. Réponds de façon utile."},
    {"role": "user", "content": "Je cherche des chaussures de running en pointure 43"}
]

response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=messages
)

messages.append(response.choices[0].message)
messages.append({"role": "user", "content": "Et les modèles imperméables ?"})

response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=messages
)

Analyse de documents avec RAG

from openai import OpenAI
import numpy as np

client = OpenAI()

def get_embedding(text):
    response = client.embeddings.create(
        model="text-embedding-3-small",
        input=text
    )
    return response.data[0].embedding

def cosine_similarity(a, b):
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))

docs = ["React est une bibliothèque pour construire des interfaces utilisateur", "Next.js est un framework React avec du SSR"]
doc_embeddings = [get_embedding(d) for d in docs]

query_embedding = get_embedding("Comment faire du rendu côté serveur ?")
similarities = [cosine_similarity(query_embedding, de) for de in doc_embeddings]
best_doc = docs[np.argmax(similarities)]

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {"role": "system", "content": f"Réponds en te basant sur : {best_doc}"},
        {"role": "user", "content": "Comment faire du rendu côté serveur ?"}
    ]
)

Modération de contenu

response = client.moderations.create(
    model="omni-moderation-latest",
    input="Vérifie si ce contenu contient des infractions"
)
print(response.results[0].flagged)

FAQ

Combien coûte l'utilisation de l'API OpenAI ?

La facturation se fait au token (des fragments de texte). Le modèle le moins cher (GPT-4.1 Nano) coûte $0.10/1M tokens en entrée. Les nouveaux comptes reçoivent des crédits gratuits pour démarrer.

En quoi les modèles GPT diffèrent-ils des modèles O ?

Les modèles GPT (GPT-4o, GPT-5) sont des modèles généralistes : rapides et polyvalents. Les modèles O (o1, o3) sont des modèles de raisonnement : ils « réfléchissent » avant de répondre, meilleurs sur les problèmes logiques et mathématiques complexes, mais plus lents et plus chers.

Peut-on faire du fine-tuning sur les modèles OpenAI ?

Oui, le fine-tuning est disponible pour GPT-4.1, GPT-4o et o4-mini. Il faut des données d'entraînement au format JSONL.

Les données envoyées à l'API sont-elles sécurisées ?

Les données de l'API ne sont pas utilisées pour l'entraînement par défaut. OpenAI les conserve 30 jours pour la surveillance. Pour les données sensibles, Zero Data Retention est disponible.

Comment choisir entre OpenAI et les alternatives ?

OpenAI a l'écosystème d'outils pour développeurs le plus large et les meilleurs modèles de raisonnement. Anthropic (Claude) se distingue par la sécurité et un contexte long. Google (Gemini) offre le contexte le plus long (2M) et une intégration à GCP. Meta (Llama) a les meilleurs modèles open source pour l'auto-hébergement.

OpenAI a-t-il des modèles open source ?

Oui, GPT-OSS (gpt-oss-120b et gpt-oss-20b) a été publié en août 2025 sous licence Apache 2.0.

Quelle est la différence entre l'API Responses et Chat Completions ?

L'API Responses est la plus récente, avec des outils intégrés (recherche web, recherche de fichiers, interpréteur de code). Chat Completions est l'API plus ancienne et plus simple. OpenAI recommande l'API Responses pour les nouveaux projets.

ChatGPT et l'API, est-ce la même chose ?

Non. ChatGPT est un produit grand public (une application de chat). L'API est un service pour les développeurs, qui permet d'intégrer les modèles dans leurs propres applications. Les deux ont des grilles tarifaires séparées.

Résumé

OpenAI est le leader de l'intelligence artificielle et propose l'écosystème d'outils pour développeurs le plus large : des modèles de langage et de vision, des SDK pour construire des agents, jusqu'aux outils de fine-tuning et d'embeddings.

Pour les développeurs, l'essentiel tient en quelques points : l'API Responses comme point d'entrée principal, le SDK Agents pour construire des workflows à plusieurs étapes, Structured Outputs pour une sortie typée, le function calling pour intégrer des services externes, et une riche bibliothèque de modèles, du moins cher (GPT-4.1 Nano) au plus puissant (o3, gpt-5.6-sol).

Que tu construises un chatbot, un système RAG, un agent IA ou un pipeline de traitement de données, la plateforme OpenAI fournit des outils pour quasiment toutes les tâches d'IA.

Une chose mérite d'être retenue au-dessus de tous les détails : les noms de modèles et les tarifs changent sur cette plateforme plus vite que le contenu de n'importe quel guide. La liste actuelle des modèles se trouve dans la documentation OpenAI, et les prix actuels sur la page des tarifs. Avant de figer un identifiant de modèle dans ton code, vérifie ces deux adresses.