For the complete documentation index, see llms.txt. Markdown versions of documentation pages are available by appending .md to the page URL.
Navigation principale
Theme

Suggestions

Recherche et récupération d’informations

Connectez des outils et des sources de données

Créez des workflows qui font appel à des outils

Ordinateur et code

Médias

Tableau de bord de l’API
Essayez ChatGPT

Utilisation de l’ordinateur

Permettez à un modèle de piloter un navigateur ou un environnement de bureau.

L’utilisation de l’ordinateur permet à un modèle de piloter un navigateur ou une interface de bureau. Utilisez cette fonctionnalité pour remplir des formulaires, tester des parcours utilisateur ou effectuer des tâches dans une application.

Choisissez une approche en fonction de ce que le modèle doit voir et de la personne ou du service qui gère l’environnement :

Tâche Pour commencer
Utiliser des captures d’écran et agir à la souris ou au clavier dans votre navigateur ou sur votre bureau Utilisez ComputerToolset avec l’outil ordinateur de l’API Responses.
Lire le texte des pages ou utiliser les commandes et les onglets de votre navigateur Utilisez BrowserToolset. Votre pilote expose certaines opérations sous forme d’outils de type fonction.
Utiliser un navigateur hébergé par OpenAI Suivez le guide dédié à l’utilisation de l’ordinateur avec l’API Agents.

Pour accéder à des informations publiques sans interagir avec une interface, utilisez la recherche web.

Utiliser le SDK

Le SDK exécute la boucle d’appels d’outils de Responses en Python ou avec Node. Votre application fournit un pilote, c’est-à-dire du code qui lit l’état de l’environnement ou effectue une action autorisée. Votre application gère la session, les autorisations et la libération des ressources.

Connecter un environnement hébergé

Utilisez le navigateur ou le bureau d’un partenaire pour éviter d’avoir à le gérer vous-même. Certaines intégrations fournissent un pilote. D’autres exposent des commandes que votre application relie au SDK. Consultez le guide du partenaire pour connaître la procédure de configuration et les versions de paquets prises en charge.

Environnement Intégration
Browserbase Utilisez le pilote de navigateur Stagehand avec une session hébergée par Browserbase. Suivez le guide d’intégration de Stagehand ou consultez les exemples en Python et TypeScript.
Browser Use Utilisez le pilote de la bibliothèque Browser Use ou connectez votre code Playwright existant avec l’intégration Browser Use Cloud. Les deux guides utilisent Python.
Daytona Utilisez ComputerToolset avec un bureau Daytona en bac à sable. Suivez le guide des fonctions utilitaires Daytona pour l’utilisation de l’ordinateur (Python). Pour un exemple avec le SDK Agents, consultez l’exemple d’utilisation de l’ordinateur avec Daytona.
E2B Desktop Effectuez des actions sur l’ordinateur ou exécutez du code dans un bureau en bac à sable. Suivez le guide E2B sur l’utilisation de l’ordinateur ou consultez les exemples en Python et en TypeScript.

Fixez un délai d’expiration pour la session et fermez-la ou libérez-la même si l’exécution échoue. Si les ressources ne sont pas libérées, consultez le tableau de bord du fournisseur. Utilisez les règles réseau du fournisseur pour limiter les sites et les ressources auxquels la session peut accéder.

Exécuter votre première tâche

Utilisez Python 3.11 ou version ultérieure, ou Node.js 22.6 ou version ultérieure. Créez et exportez une clé API. Les deux exemples utilisent un navigateur local temporaire et effectuent des appels à l’API Responses qui peuvent entraîner des frais.

Installez les paquets et Chromium dans un nouveau dossier :

# Python
python3 -m venv .venv
.venv/bin/python -m pip install openai==3.31.0 playwright==1.61.0
.venv/bin/python -m playwright install chromium

# Node
npm install openai@7.33.0 playwright@1.61.1
npx playwright install chromium

Sous Windows, utilisez py -3 à la place de python3 et .venv\Scripts\python.exe à la place de .venv/bin/python.

Le modèle voit une capture d’écran d’une page fictive de retrait de colis et clique pour afficher les informations de retrait. Le pilote autorise uniquement les captures d’écran et le clic gauche sur la commande correspondante. Il bloque les requêtes de la page et ferme le navigateur à la fin de l’exécution. Le script envoie au maximum six requêtes à l’API Responses et vérifie la page avant d’annoncer que la tâche a réussi. Votre projet doit avoir accès à un modèle qui prend en charge l’outil ordinateur.

Enregistrez l’exemple correspondant sous le nom pickup.py ou pickup.mjs :

Afficher les informations de retrait à l’aide d’actions sur l’ordinateur
import asyncio
import base64

from openai import AsyncComputerToolset, AsyncOpenAI
from playwright.async_api import async_playwright


class PickupDriver:
    def __init__(self, page):
        self.page = page

    async def screenshot(self):
        image = await self.page.screenshot(type="png")
        return {
            "type": "computer_screenshot",
            "image_url": "data:image/png;base64," + base64.b64encode(image).decode(),
        }

    async def allowed(self, action):
        if action.type == "screenshot":
            return True
        if action.type != "click" or action.button != "left" or action.keys:
            return False
        box = await self.page.locator("summary").bounding_box()
        return bool(
            box
            and box["x"] <= action.x < box["x"] + box["width"]
            and box["y"] <= action.y < box["y"] + box["height"]
        )

    async def click(self, action):
        # The page may have changed after approval, so bind the click again.
        if not await self.allowed(action):
            raise RuntimeError("Pickup details moved or the click is not allowed.")
        await self.page.mouse.click(action.x, action.y)

    async def refuse(self, action):
        raise RuntimeError(f"This exercise does not allow {action.type}.")

    double_click = drag = keypress = move = scroll = type = wait = refuse


async def main():
    async with (
        async_playwright() as playwright,
        AsyncOpenAI(timeout=30, max_retries=0) as client,
    ):
        browser = await playwright.chromium.launch(env={}, chromium_sandbox=True)
        try:
            page = await browser.new_page(viewport={"width": 1024, "height": 768})
            await page.route("**/*", lambda route: route.abort())
            await page.set_content(
                "<title>Parcel pickup</title><main>"
                "<h1>Parcel pickup</h1><p>Order #1042 is ready.</p>"
                "<details><summary>Show pickup details</summary>"
                "<p>Locker 18. Pickup code: 6249.</p></details></main>"
            )
            driver = PickupDriver(page)
            tools = AsyncComputerToolset(driver)
            try:
                response = await tools.run(
                    client,
                    {
                        "model": "gpt-6.1-sol",
                        "store": False,
                        "input": "Take a screenshot. Open 'Show pickup details' and report the locker and pickup code. Use only screenshots and left clicks.",
                    },
                    before_action=driver.allowed,
                    max_steps=6,
                )
                if await page.locator("details").get_attribute("open") is None:
                    raise RuntimeError("Pickup details are still closed.")
                print(
                    "Verified pickup details:",
                    await page.locator("details p").inner_text(),
                )
                print("Answer:", response.output_text)
            finally:
                tools.close()
        finally:
            await browser.close()


if __name__ == "__main__":
    asyncio.run(main())

Exécutez .venv/bin/python pickup.py ou node pickup.mjs. Si la tâche réussit, le script affiche Verified pickup details: Locker 18. Pickup code: 6249., puis la réponse du modèle. Toute vérification de sécurité de l’API en attente interrompt cet exemple. N’ajoutez une fonction de rappel pour l’approbation humaine que si votre application peut gérer ces vérifications.

Si l’API refuse l’outil ou si Chromium ne démarre pas, consultez les instructions de dépannage. Si les clics manquent leur cible, vérifiez la capture d’écran et les coordonnées.

Vérifier l’accès au modèle, les coûts et le traitement des données

  • Modèle : pour les outils de navigateur de type fonction, vérifiez que le modèle prend en charge l’API Responses et l’appel de fonction. Si votre pilote renvoie des images, vérifiez aussi que le modèle les accepte en entrée. Pour les actions sur l’ordinateur fondées sur des captures d’écran, vérifiez que l’utilisation de l’ordinateur figure dans la section Tools du modèle. Consultez le catalogue des modèles et vérifiez les droits d’accès de votre projet.
  • Coût : chaque requête à l’API Responses peut entraîner des frais pour les tokens d’entrée et de sortie. Les captures d’écran sont comptabilisées comme des images en entrée. Consultez les tarifs de l’API, estimez le coût des images en entrée ou examinez la consommation par requête. L’environnement hébergé peut faire l’objet d’une facturation distincte.
  • Données : le SDK envoie à OpenAI le texte des pages ou les captures d’écran que le pilote renvoie. Les exemples définissent store sur false, mais ce réglage n’exclut pas toute conservation des données. Consultez les options de contrôle des données et les exceptions applicables aux images en entrée. Le fournisseur de votre environnement applique sa propre politique en matière de données.

Observer et approuver les modifications

Essayez ensuite la démo de réservation en Python ou avec Node. Elle remplit un formulaire de réservation fictif, demande votre approbation avant l’envoi, puis vérifie les champs enregistrés et la confirmation. Vous pouvez observer le navigateur, en prendre le contrôle, le rendre au modèle ou arrêter l’exécution. Les deux versions permettent de faire un essai en local avec un véritable navigateur, sans appel à l’API.

Pour observer les actions du SDK sur un bureau, essayez la démo visuelle sur un bureau.

Adapter le pilote

Remplacez la page d’exemple par un environnement que votre application contrôle. Pour un pilote de navigateur, utilisez members pour exposer uniquement les opérations nécessaires à la tâche. Pour un pilote d’ordinateur, implémentez les méthodes requises et refusez les actions non prises en charge. Gardez la session ouverte jusqu’à la fin de l’exécution, puis libérez les ressources créées par votre application.

Le contenu des pages peut influencer le modèle. Utilisez un nouveau profil de navigateur ou un bureau isolé. Limitez l’accès au réseau et veillez à ce que les identifiants de connexion n’apparaissent ni dans le texte des pages ni dans les captures d’écran. Demandez une approbation avant toute modification et vérifiez le résultat enregistré avant d’annoncer que la tâche a réussi. Consultez la documentation de référence des pilotes pour connaître les contrats des méthodes, le mécanisme d’approbation, les règles applicables aux URL et les procédures de reprise.

Passer à Decisions pour des choix prédéfinis

Utilisez Responses lorsque le modèle doit choisir les actions et générer leurs arguments. Utilisez Decisions uniquement si votre application connaît déjà toutes les actions autorisées ainsi que l’intégralité de leurs arguments. Par exemple, une application peut proposer route_billing, route_technical et review. Decisions sélectionne une option. Il revient ensuite à votre application de l’approuver, de l’exécuter et de vérifier le résultat. Dès que la page change, écartez les choix précédents. Consultez le guide de Decisions.

Pour essayer Decisions dans la démo de réservation, utilisez une clé qui donne accès à Decisions, définissez OPENAI_DECISIONS_MODEL et redémarrez le serveur. Lancez une nouvelle exécution et sélectionnez Decisions.

Utiliser directement l’API

Utilisez directement l’API Responses si vous devez gérer vous-même la boucle d’appels d’outils. Vous fournissez l’environnement et exécutez les actions demandées par le modèle. Choisissez comment relier cet environnement à votre application :

  • Exécution de code : le modèle écrit du code qui utilise une bibliothèque comme PyAutoGUI ou Playwright pour piloter l’interface. Un seul appel peut combiner des actions, des boucles ou des conditions.
  • Outil ordinateur : le modèle renvoie des actions structurées à la souris et au clavier. Votre application les convertit en entrées pour le navigateur ou le bureau.

Pour GPT-6 Astra, nous recommandons l’exécution de code. L’outil computer reste disponible comme autre option.

Si vous exposez déjà des opérations sur l’interface utilisateur via l’appel de fonction ou des outils MCP distants, vous pouvez conserver cette interface. Consultez la section Utiliser vos propres outils d’interface utilisateur pour comprendre comment l’exécution des outils et le renvoi des résultats diffèrent selon l’intégration.

Utiliser l’exécution de code

Une intégration par exécution de code met à la disposition du modèle un outil de type fonction qui accepte un script. Votre application exécute le script dans un navigateur isolé ou un environnement de bureau isolé et renvoie sa sortie, y compris les captures d’écran. Gardez l’environnement disponible entre les appels pour que le modèle puisse poursuivre le travail entamé.

Exécuter l’application d’exemple

L’application d’exemple CUA propose deux implémentations, JavaScript/Playwright et Python/PyAutoGUI, avec des tâches locales et une console commune :

  1. Suivez les instructions de configuration de l’implémentation choisie dans un environnement isolé.
  2. Choisissez un scénario intégré et lancez son exécution.
  3. Examinez les actions, les captures d’écran et l’état final pour déterminer si la tâche a réussi.

Consultez le README de l’application pour les instructions d’installation, les autorisations du bureau et les environnements pris en charge. Lisez la section Exécuter les tâches en toute sécurité avant d’adapter l’application à des sites ou à des comptes réels.

Connecter votre propre environnement d’exécution

L’exemple suivant illustre la boucle d’appels à l’API pour un environnement d’exécution que vous fournissez. Les clients Python, Ruby et Go envoient du code Python à un environnement de bureau qui utilise PyAutoGUI. Le client JavaScript utilise Playwright pour piloter un navigateur. Chaque client expose un outil de type fonction classique et renvoie du texte ou des images avec le call_id d’origine.

La fonction utilitaire execute_in_sandbox ou executeInSandbox envoie du code à votre environnement d’exécution et renvoie les observations obtenues. Elle doit conserver la session du navigateur ou du bureau, faire respecter les limites d’exécution et appliquer vos règles d’autorisation. Ces exemples illustrent l’intégration de votre propre environnement, indépendamment de l’exécution de l’application d’exemple.
Piloter l’ordinateur en exécutant du code
import json
import uuid

from openai import OpenAI
from openai.types.responses import (
    FunctionToolParam,
    ResponseInputParam,
)

def run_computer_use(endpoint, prompt, model="gpt-6-astra"):
    client = OpenAI()
    session_id = str(uuid.uuid4())
    tools: list[FunctionToolParam] = [
        {
            "type": "function",
            "name": "exec_py",
            "description": (
                "Run Python in a persistent desktop. Variables persist across calls. "
                "PyAutoGUI operations are synchronous. Available: pyautogui, time, "
                "log(value), and display(PIL_image). Inspect the screen with "
                "display(pyautogui.screenshot()) before acting. Use screenshot "
                "coordinates and check the screen after a short group of actions. "
                "Keep screenshots in memory and PyAutoGUI's fail-safe enabled."
            ),
            "parameters": {
                "type": "object",
                "properties": {"code": {"type": "string"}},
                "required": ["code"],
                "additionalProperties": False,
            },
            "strict": True,
        }
    ]
    next_input: ResponseInputParam = [{"role": "user", "content": prompt}]
    previous_response_id = None

    for turn in range(20):
        response = client.responses.create(
            model=model,
            tools=tools,
            input=next_input,
            previous_response_id=previous_response_id,
        )
        if response.status != "completed":
            raise RuntimeError(f"Response stopped with status: {response.status}")

        calls = [item for item in response.output if item.type == "function_call"]
        if not calls and any(
            item.type == "message" and item.phase != "commentary"
            for item in response.output
        ):
            print(response.output_text)
            return
        if turn == 19:
            raise RuntimeError(
                "The task reached the 20-response limit. Inspect the last result."
            )

        next_input = []
        for call in calls:
            if call.name != "exec_py":
                raise ValueError(f"Unexpected tool: {call.name}")
            code = json.loads(call.arguments)["code"]
            output = execute_in_sandbox(code, session_id, endpoint)
            next_input.append(
                {
                    "type": "function_call_output",
                    "call_id": call.call_id,
                    "output": output,
                }
            )
        previous_response_id = response.id

Pour obtenir un adaptateur client complet et connaître le format attendu pour le texte et les images en sortie, consultez la section Se connecter à son service d’exécution. Dans ces exemples, l’interface du service appartient à votre application. Il ne s’agit pas d’un point de terminaison hébergé par OpenAI.

Conserver l’état et renvoyer les observations

Maintenez la session du navigateur ou du bureau ouverte entre les appels. Un espace de noms Python ou JavaScript persistant permet également de conserver les variables. Décrivez les objets et les fonctions utilitaires disponibles dans la définition de l’outil pour que le modèle sache ce qu’il peut utiliser.

Si l’état de l’interface est inconnu, fournissez au modèle une capture de l’écran actuel. Après une courte série d’actions, renvoyez une nouvelle capture pour qu’il puisse vérifier le résultat. Gardez les images en mémoire et utilisez detail: "original" pour conserver leur résolution. Si vous réduisez la résolution d’une capture, convertissez les coordonnées du modèle dans le système de coordonnées de l’environnement avant d’exécuter les actions. Consultez la section Captures d’écran et résolution.

La conversation avec l’API et l’environnement d’exécution ont chacun leur propre état. Conservez les appels d’outils et leurs sorties dans la conversation, et gardez l’environnement correspondant disponible dans votre application. Poursuivre une réponse ne restaure ni la session du navigateur, ni l’état de connexion, ni les variables de l’environnement d’exécution.

Utiliser l’outil ordinateur

Utilisez cette option si votre intégration attend des actions structurées plutôt que du code généré.

Pour essayer cette approche, suivez la même procédure de configuration de l’application d’exemple, sélectionnez le mode Native et exécutez un scénario intégré. Utilisez un modèle qui prend en charge l’outil ordinateur.

L’échange avec l’API se déroule en trois étapes : envoyez une tâche, exécutez les actions renvoyées, puis renvoyez une capture d’écran. Les extraits de code ci-dessous utilisent une page qui comporte une commande Show filters et un champ de recherche. Adaptez cette tâche à votre propre interface lorsque vous intégrez l’outil.

Pour configurer l’environnement et mettre en place les gestionnaires d’actions, consultez les exemples pratiques d’intégration.

Envoyer la tâche

Activez computer dans le tableau tools et décrivez le résultat souhaité :

Envoyer une requête à l’outil ordinateur
from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-6.1-sol",
    tools=[{"type": "computer"}],
    input="Check whether the Filters panel is open. If it is not open, click Show filters. Then type penguin in the search box. Use the computer tool for UI interaction.",
)

print(response.output)

Exécuter les actions demandées

Un appel computer_call contient un tableau ordonné actions. Par exemple, l’appel suivant sélectionne le champ de recherche et y saisit penguin :

Regrouper plusieurs actions en un seul tour
{
  "output": [
    {
      "type": "computer_call",
      "call_id": "call_002",
      "actions": [
        { "type": "click", "button": "left", "x": 405, "y": 157 },
        { "type": "type", "text": "penguin" }
      ],
      "status": "completed"
    }
  ]
}

Votre gestionnaire d’actions convertit ces demandes en entrées pour le navigateur ou le système d’exploitation. Exécutez les actions autorisées dans l’ordre, puis capturez l’écran mis à jour. Le modèle peut demander les actions click, double_click, drag, move, scroll, keypress, type, wait ou screenshot.

Le premier appel peut contenir uniquement une action screenshot. Dans ce cas, capturez l’écran actuel et renvoyez la capture sans modifier l’interface. Si l’appel indique status: "completed", le modèle a fini de générer cet appel. Votre application doit encore l’exécuter.

Consultez les exemples de gestionnaires d’actions pour les correspondances entre touches, les trajectoires de glissement et les touches de modification.

Renvoyer la capture d’écran

Renvoyez un élément computer_call_output dont le call_id correspond à celui de l’appel traité. Utilisez previous_response_id pour poursuivre la conversation avec le modèle :

Envoyer la capture de l’écran mis à jour
from openai import OpenAI

client = OpenAI()


def send_computer_screenshot(response, call_id, screenshot_base64):
    return client.responses.create(
        model="gpt-6.1-sol",
        tools=[{"type": "computer"}],
        previous_response_id=response.id,
        input=[
            {
                "type": "computer_call_output",
                "call_id": call_id,
                "output": {
                    "type": "computer_screenshot",
                    "image_url": f"data:image/png;base64,{screenshot_base64}",
                    "detail": "original",
                },
            }
        ],
    )

Les mêmes consignes sur les captures d’écran et la conservation de l’état s’appliquent à cette boucle. Gardez l’environnement disponible pendant que vous poursuivez la conversation avec le modèle à l’aide de previous_response_id.

Continuez jusqu’à ce que le modèle cesse de renvoyer des éléments computer_call. Examinez le reste de la sortie pour y repérer une réponse, une demande d’aide ou un autre appel d’outil, puis vérifiez le résultat dans l’application. Dans cet exemple, le panneau Filters doit être ouvert et le champ de recherche doit contenir penguin.

Consultez la section Répéter la boucle d’utilisation de l’ordinateur pour voir la structure de la boucle et les fonctions utilitaires nécessaires à l’exécution des actions et aux captures d’écran.

Exécuter les tâches en toute sécurité

L’utilisation de l’ordinateur peut avoir des effets sur des comptes et des données réels. Appliquez les mesures suivantes dans votre application et votre environnement d’exécution, ainsi que dans les instructions du modèle :

  • Restreignez l’environnement. Utilisez un navigateur isolé ou une machine virtuelle isolée et définissez une liste de sites et d’actions autorisés. Limitez les accès à ce que la tâche exige.
  • Considérez le contenu à l’écran comme non fiable. Le texte d’une page, d’un document ou du résultat d’un outil ne peut ni accorder une autorisation ni remplacer les instructions de l’utilisateur.
  • Faites confirmer les actions lourdes de conséquences. Laissez aux utilisateurs le contrôle des achats, de la transmission de données, des modifications destructrices et des autres actions difficiles à annuler. La saisie d’informations sensibles dans un formulaire constitue une transmission.
  • Fixez des limites et vérifiez le résultat. Limitez le nombre d’étapes, la durée ou le coût, prévoyez la possibilité d’annuler l’exécution et vérifiez le résultat réel sans vous fier uniquement à la réponse finale du modèle.

Consultez les consignes sur la confirmation et le consentement pour connaître les exigences précises d’approbation, savoir quand passer la main à une personne et voir des exemples de prompts.

Étapes suivantes