Configurer Computer Use dans l'API — Computer Use et Automatisation

Leçon réécrite le 3 novembre 2026 d’après le guide Computer use et les Computer use integration recipes d’OpenAI : la configuration passe par le SDK openai, la variable OPENAI_API_KEY et l’outil {"type": "computer"} de la Responses API, et non plus par le SDK d’Anthropic et l’outil computer_20241022 de l’ancienne version. L’outil d’OpenAI ne prend pas de dimensions d’écran : les coordonnées se rapportent à la capture que vous renvoyez. Sources : Computer use · Integration recipes.

Ce qu’il faut avoir sous la main

Le poste de travail doit réunir quatre choses avant la première ligne de code : une version récente de Python 3, un compte OpenAI avec une clé d’API active et l’accès à un modèle qui prend en charge l’outil computer, un navigateur Chromium piloté par Playwright pour les interactions web, et Docker si vous voulez isoler l’agent. Ce dernier point reste optionnel au stade de l’apprentissage, mais OpenAI recommande un navigateur ou une machine virtuelle isolés dès que l’agent touche à autre chose qu’un site de démonstration.

Pour le modèle, la documentation d’OpenAI emploie gpt-6.1-sol dans ses exemples de l’outil computer ; vérifiez dans la fiche du modèle (section Tools) que l’utilisation de l’ordinateur y figure, et que votre projet y a accès.

Installer les dépendances

Travaillez dans un environnement virtuel dédié : un agent Computer Use épingle des versions précises de Playwright et de ses navigateurs, et le mélanger à vos autres projets Python vous vaudra des conflits pénibles à diagnostiquer.

# Créer et activer l'environnement
python -m venv computer-use-env
source computer-use-env/bin/activate  # Linux/Mac
# computer-use-env\Scripts\activate   # Windows

# Installer les dépendances
pip install openai playwright pillow

# Installer le navigateur Playwright
playwright install chromium

Chacun de ces paquets joue un rôle distinct : openai fournit le client qui parle au modèle, playwright pilote le navigateur et exécute les actions, pillow sert aux manipulations d’images quand vous en avez besoin. La dernière commande est celle qu’on oublie le plus souvent : sans playwright install chromium, le paquet est bien présent mais aucun navigateur n’a été téléchargé, et le premier lancement échoue.

Placer la clé d’API au bon endroit

La clé vit dans une variable d’environnement, jamais en dur dans un script : un secret écrit dans le code finit tôt ou tard dans un dépôt Git.

export OPENAI_API_KEY="votre-clé"

En production, passez par un gestionnaire de secrets. Le client lit la variable tout seul :

from openai import OpenAI

client = OpenAI()  # lit OPENAI_API_KEY

Déclarer l’outil computer

Un modèle ne contrôle pas un écran par défaut : il faut lui ouvrir l’outil computer dans la requête, et décrire le résultat attendu.

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-6.1-sol",
    tools=[{"type": "computer"}],
    input=(
        "Vérifie si le panneau Filtres est ouvert. S'il ne l'est pas, "
        "clique sur Afficher les filtres, puis tape pingouin dans le champ "
        "de recherche. Utilise l'outil computer pour agir sur l'interface."
    ),
)
print(response.output)

La déclaration tient en {"type": "computer"} : contrairement à l’ancienne version préliminaire de l’outil (computer_use_preview), elle ne prend ni dimensions d’écran ni type d’environnement, et la troncature automatique n’est plus nécessaire. Les coordonnées que renvoie le modèle se rapportent à la capture que vous lui envoyez : capturez donc exactement la zone sur laquelle vous cliquerez, à la même échelle. Si vous redimensionnez une capture avant de l’envoyer, convertissez les coordonnées en sens inverse avant d’agir.

Configurer le navigateur

Côté Playwright, le lancement gagne à être encapsulé dans une fonction que vous réutiliserez dans toutes vos tâches.

from playwright.sync_api import sync_playwright

def lancer_navigateur(largeur=1280, hauteur=720):
    """Lance un navigateur isolé pour Computer Use."""
    pw = sync_playwright().start()
    browser = pw.chromium.launch(headless=True)  # False pour regarder l'agent
    context = browser.new_context(viewport={"width": largeur, "height": hauteur})
    page = context.new_page()
    return pw, browser, page

page.screenshot() capture le viewport : les coordonnées du modèle s’appliquent alors telles quelles à page.mouse. L’option headless=True lance le navigateur sans interface, ce qui est indispensable sur un serveur ; pendant le développement, passez à False pour regarder l’agent travailler — c’est le moyen le plus rapide de comprendre pourquoi il se trompe.

Organiser le projet

Séparez dès le départ ce qui relève du navigateur, de la boucle d’agent et de l’exécution des actions.

computer-use-project/
├── .env                  # OPENAI_API_KEY (jamais versionné)
├── requirements.txt      # openai, playwright, pillow
├── src/
│   ├── __init__.py
│   ├── navigateur.py     # Lancement et capture
│   ├── agent.py          # Boucle Computer Use
│   └── actions.py        # Exécution des actions
└── taches/
    └── exemple.py        # Scripts de tâches

Vérifier l’installation avant d’aller plus loin

Ne construisez pas un workflow complexe sur une configuration non validée : au premier échec, vous ne sauriez plus s’il vient de la clé, du navigateur ou de votre prompt. Ce script minimal teste la chaîne entière — client, navigateur, capture et envoi d’une image au modèle.

import base64

from openai import OpenAI
from playwright.sync_api import sync_playwright

def tester_installation():
    """Vérifie que la clé, le navigateur et l'envoi d'image fonctionnent."""
    client = OpenAI()

    pw = sync_playwright().start()
    browser = pw.chromium.launch(headless=True)
    page = browser.new_page(viewport={"width": 1280, "height": 720})
    page.goto("https://example.com")
    capture = base64.b64encode(page.screenshot()).decode("utf-8")

    response = client.responses.create(
        model="gpt-6.1-sol",
        input=[{
            "role": "user",
            "content": [
                {"type": "input_text", "text": "Décris ce que tu vois."},
                {"type": "input_image", "image_url": f"data:image/png;base64,{capture}"},
            ],
        }],
    )
    print("Réponse :", response.output_text)

    browser.close()
    pw.stop()

if __name__ == "__main__":
    tester_installation()

Si la console affiche une description de la page example.com, votre configuration est opérationnelle et vous pouvez passer à la construction d’un agent complet.

Points clés à retenir

Installez openai, playwright et pillow dans un environnement virtuel dédié, puis playwright install chromium
La clé OPENAI_API_KEY reste dans une variable d’environnement, jamais dans le code
L’outil se déclare par tools=[{"type": "computer"}], avec un modèle qui le prend en charge (les exemples d’OpenAI utilisent gpt-6.1-sol)
Les coordonnées du modèle se rapportent à la capture envoyée : capturez la zone sur laquelle vous agissez, à la même échelle
Testez toujours avec un script minimal avant de construire des workflows complexes